dlls/advapi32/registry.c

   1 /*
   2  * Registry management
   3  *
   4  * Copyright (C) 1999 Alexandre Julliard
   5  * Copyright (C) 2017 Dmitry Timoshkov
   6  *
   7  * Based on misc/registry.c code
   8  * Copyright (C) 1996 Marcus Meissner
   9  * Copyright (C) 1998 Matthew Becker
  10  * Copyright (C) 1999 Sylvain St-Germain
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2.1 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with this library; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  25  */
  26
  27 #include <stdlib.h>
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30
  31 #include "ntstatus.h"
  32 #define WIN32_NO_STATUS
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "winreg.h"
  36 #include "winerror.h"
  37 #include "winternl.h"
  38
  39 #include "wine/debug.h"
  40 #include "wine/list.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(reg);
  43
  44 NTSTATUS WINAPI RemapPredefinedHandleInternal( HKEY hkey, HKEY override );
  45 NTSTATUS WINAPI DisablePredefinedHandleTableInternal( HKEY hkey );
  46
  47
  48 /******************************************************************************
  49  * RegOverridePredefKey   [ADVAPI32.@]
  50  */
  51 LSTATUS WINAPI RegOverridePredefKey( HKEY hkey, HKEY override )
  52 {
  53     return RtlNtStatusToDosError( RemapPredefinedHandleInternal( hkey, override ));
  54 }
  55
  56
  57 /******************************************************************************
  58  * RegCreateKeyW   [ADVAPI32.@]
  59  *
  60  * Creates the specified reg key.
  61  *
  62  * PARAMS
  63  *  hKey      [I] Handle to an open key.
  64  *  lpSubKey  [I] Name of a key that will be opened or created.
  65  *  phkResult [O] Receives a handle to the opened or created key.
  66  *
  67  * RETURNS
  68  *  Success: ERROR_SUCCESS
  69  *  Failure: nonzero error code defined in Winerror.h
  70  */
  71 LSTATUS WINAPI RegCreateKeyW( HKEY hkey, LPCWSTR lpSubKey, PHKEY phkResult )
  72 {
  73     return RegCreateKeyExW( hkey, lpSubKey, 0, NULL, REG_OPTION_NON_VOLATILE,
  74                             MAXIMUM_ALLOWED, NULL, phkResult, NULL );
  75 }
  76
  77
  78 /******************************************************************************
  79  * RegCreateKeyA   [ADVAPI32.@]
  80  *
  81  * See RegCreateKeyW.
  82  */
  83 LSTATUS WINAPI RegCreateKeyA( HKEY hkey, LPCSTR lpSubKey, PHKEY phkResult )
  84 {
  85     return RegCreateKeyExA( hkey, lpSubKey, 0, NULL, REG_OPTION_NON_VOLATILE,
  86                             MAXIMUM_ALLOWED, NULL, phkResult, NULL );
  87 }
  88
  89
  90 /******************************************************************************
  91  * RegCreateKeyTransactedW   [ADVAPI32.@]
  92  */
  93 LSTATUS WINAPI RegCreateKeyTransactedW( HKEY hkey, LPCWSTR name, DWORD reserved, LPWSTR class,
  94                                         DWORD options, REGSAM access, SECURITY_ATTRIBUTES *sa,
  95                                         PHKEY retkey, LPDWORD dispos, HANDLE transaction, PVOID reserved2 )
  96 {
  97     FIXME( "(%p,%s,%lu,%s,%lu,%lu,%p,%p,%p,%p,%p): stub\n", hkey, debugstr_w(name), reserved,
  98            debugstr_w(class), options, access, sa, retkey, dispos, transaction, reserved2 );
  99     return ERROR_CALL_NOT_IMPLEMENTED;
 100 }
 101
 102
 103 /******************************************************************************
 104  * RegCreateKeyTransactedA   [ADVAPI32.@]
 105  */
 106 LSTATUS WINAPI RegCreateKeyTransactedA( HKEY hkey, LPCSTR name, DWORD reserved, LPSTR class,
 107                                         DWORD options, REGSAM access, SECURITY_ATTRIBUTES *sa,
 108                                         PHKEY retkey, LPDWORD dispos, HANDLE transaction, PVOID reserved2 )
 109 {
 110     FIXME( "(%p,%s,%lu,%s,%lu,%lu,%p,%p,%p,%p,%p): stub\n", hkey, debugstr_a(name), reserved,
 111            debugstr_a(class), options, access, sa, retkey, dispos, transaction, reserved2 );
 112     return ERROR_CALL_NOT_IMPLEMENTED;
 113 }
 114
 115
 116 /******************************************************************************
 117  * RegOpenKeyW   [ADVAPI32.@]
 118  *
 119  * See RegOpenKeyA.
 120  */
 121 LSTATUS WINAPI RegOpenKeyW( HKEY hkey, LPCWSTR name, PHKEY retkey )
 122 {
 123     if (!retkey)
 124         return ERROR_INVALID_PARAMETER;
 125
 126     if (!name || !*name)
 127     {
 128         *retkey = hkey;
 129         return ERROR_SUCCESS;
 130     }
 131     return RegOpenKeyExW( hkey, name, 0, MAXIMUM_ALLOWED, retkey );
 132 }
 133
 134
 135 /******************************************************************************
 136  * RegOpenKeyA   [ADVAPI32.@]
 137  *
 138  * Open a registry key.
 139  *
 140  * PARAMS
 141  *  hkey    [I] Handle of parent key to open the new key under
 142  *  name    [I] Name of the key under hkey to open
 143  *  retkey  [O] Destination for the resulting Handle
 144  *
 145  * RETURNS
 146  *  Success: ERROR_SUCCESS
 147  *  Failure: A standard Win32 error code. When retkey is valid, *retkey is set to 0.
 148  */
 149 LSTATUS WINAPI RegOpenKeyA( HKEY hkey, LPCSTR name, PHKEY retkey )
 150 {
 151     if (!retkey)
 152         return ERROR_INVALID_PARAMETER;
 153
 154     if (!name || !*name)
 155     {
 156         *retkey = hkey;
 157         return ERROR_SUCCESS;
 158     }
 159     return RegOpenKeyExA( hkey, name, 0, MAXIMUM_ALLOWED, retkey );
 160 }
 161
 162
 163 /******************************************************************************
 164  * RegEnumKeyW   [ADVAPI32.@]
 165  *
 166  * Enumerates subkeys of the specified open reg key.
 167  *
 168  * PARAMS
 169  *  hKey    [I] Handle to an open key.
 170  *  dwIndex [I] Index of the subkey of hKey to retrieve.
 171  *  lpName  [O] Name of the subkey.
 172  *  cchName [I] Size of lpName in TCHARS.
 173  *
 174  * RETURNS
 175  *  Success: ERROR_SUCCESS
 176  *  Failure: system error code. If there are no more subkeys available, the
 177  *           function returns ERROR_NO_MORE_ITEMS.
 178  */
 179 LSTATUS WINAPI RegEnumKeyW( HKEY hkey, DWORD index, LPWSTR name, DWORD name_len )
 180 {
 181     return RegEnumKeyExW( hkey, index, name, &name_len, NULL, NULL, NULL, NULL );
 182 }
 183
 184
 185 /******************************************************************************
 186  * RegEnumKeyA   [ADVAPI32.@]
 187  *
 188  * See RegEnumKeyW.
 189  */
 190 LSTATUS WINAPI RegEnumKeyA( HKEY hkey, DWORD index, LPSTR name, DWORD name_len )
 191 {
 192     return RegEnumKeyExA( hkey, index, name, &name_len, NULL, NULL, NULL, NULL );
 193 }
 194
 195
 196 /******************************************************************************
 197  * RegQueryMultipleValuesA   [ADVAPI32.@]
 198  *
 199  * Retrieves the type and data for a list of value names associated with a key.
 200  *
 201  * PARAMS
 202  *  hKey       [I] Handle to an open key.
 203  *  val_list   [O] Array of VALENT structures that describes the entries.
 204  *  num_vals   [I] Number of elements in val_list.
 205  *  lpValueBuf [O] Pointer to a buffer that receives the data for each value.
 206  *  ldwTotsize [I/O] Size of lpValueBuf.
 207  *
 208  * RETURNS
 209  *  Success: ERROR_SUCCESS. ldwTotsize contains num bytes copied.
 210  *  Failure: nonzero error code from Winerror.h ldwTotsize contains num needed
 211  *           bytes.
 212  */
 213 LSTATUS WINAPI RegQueryMultipleValuesA( HKEY hkey, PVALENTA val_list, DWORD num_vals,
 214                                         LPSTR lpValueBuf, LPDWORD ldwTotsize )
 215 {
 216     unsigned int i;
 217     DWORD maxBytes = *ldwTotsize;
 218     LSTATUS status;
 219     LPSTR bufptr = lpValueBuf;
 220     *ldwTotsize = 0;
 221
 222     TRACE("(%p,%p,%ld,%p,%p=%ld)\n", hkey, val_list, num_vals, lpValueBuf, ldwTotsize, *ldwTotsize);
 223
 224     for(i=0; i < num_vals; ++i)
 225     {
 226
 227         val_list[i].ve_valuelen=0;
 228         status = RegQueryValueExA(hkey, val_list[i].ve_valuename, NULL, NULL, NULL, &val_list[i].ve_valuelen);
 229         if(status != ERROR_SUCCESS)
 230         {
 231             return status;
 232         }
 233
 234         if(lpValueBuf != NULL && *ldwTotsize + val_list[i].ve_valuelen <= maxBytes)
 235         {
 236             status = RegQueryValueExA(hkey, val_list[i].ve_valuename, NULL, &val_list[i].ve_type,
 237                                       (LPBYTE)bufptr, &val_list[i].ve_valuelen);
 238             if(status != ERROR_SUCCESS)
 239             {
 240                 return status;
 241             }
 242
 243             val_list[i].ve_valueptr = (DWORD_PTR)bufptr;
 244
 245             bufptr += val_list[i].ve_valuelen;
 246         }
 247
 248         *ldwTotsize += val_list[i].ve_valuelen;
 249     }
 250     return lpValueBuf != NULL && *ldwTotsize <= maxBytes ? ERROR_SUCCESS : ERROR_MORE_DATA;
 251 }
 252
 253
 254 /******************************************************************************
 255  * RegQueryMultipleValuesW   [ADVAPI32.@]
 256  *
 257  * See RegQueryMultipleValuesA.
 258  */
 259 LSTATUS WINAPI RegQueryMultipleValuesW( HKEY hkey, PVALENTW val_list, DWORD num_vals,
 260                                         LPWSTR lpValueBuf, LPDWORD ldwTotsize )
 261 {
 262     unsigned int i;
 263     DWORD maxBytes = *ldwTotsize;
 264     LSTATUS status;
 265     LPSTR bufptr = (LPSTR)lpValueBuf;
 266     *ldwTotsize = 0;
 267
 268     TRACE("(%p,%p,%ld,%p,%p=%ld)\n", hkey, val_list, num_vals, lpValueBuf, ldwTotsize, *ldwTotsize);
 269
 270     for(i=0; i < num_vals; ++i)
 271     {
 272         val_list[i].ve_valuelen=0;
 273         status = RegQueryValueExW(hkey, val_list[i].ve_valuename, NULL, NULL, NULL, &val_list[i].ve_valuelen);
 274         if(status != ERROR_SUCCESS)
 275         {
 276             return status;
 277         }
 278
 279         if(lpValueBuf != NULL && *ldwTotsize + val_list[i].ve_valuelen <= maxBytes)
 280         {
 281             status = RegQueryValueExW(hkey, val_list[i].ve_valuename, NULL, &val_list[i].ve_type,
 282                                       (LPBYTE)bufptr, &val_list[i].ve_valuelen);
 283             if(status != ERROR_SUCCESS)
 284             {
 285                 return status;
 286             }
 287
 288             val_list[i].ve_valueptr = (DWORD_PTR)bufptr;
 289
 290             bufptr += val_list[i].ve_valuelen;
 291         }
 292
 293         *ldwTotsize += val_list[i].ve_valuelen;
 294     }
 295     return lpValueBuf != NULL && *ldwTotsize <= maxBytes ? ERROR_SUCCESS : ERROR_MORE_DATA;
 296 }
 297
 298
 299 /******************************************************************************
 300  * RegQueryReflectionKey   [ADVAPI32.@]
 301  */
 302 LONG WINAPI RegQueryReflectionKey( HKEY hkey, BOOL *is_reflection_disabled )
 303 {
 304     FIXME( "%p, %p stub\n", hkey, is_reflection_disabled );
 305     *is_reflection_disabled = TRUE;
 306     return ERROR_CALL_NOT_IMPLEMENTED;
 307 }
 308
 309
 310 /******************************************************************************
 311  * RegDeleteKeyW   [ADVAPI32.@]
 312  *
 313  * See RegDeleteKeyA.
 314  */
 315 LSTATUS WINAPI RegDeleteKeyW( HKEY hkey, LPCWSTR name )
 316 {
 317     return RegDeleteKeyExW( hkey, name, 0, 0 );
 318 }
 319
 320
 321 /******************************************************************************
 322  * RegDeleteKeyA   [ADVAPI32.@]
 323  *
 324  * Delete a registry key.
 325  *
 326  * PARAMS
 327  *  hkey   [I] Handle to parent key containing the key to delete
 328  *  name   [I] Name of the key user hkey to delete
 329  *
 330  * NOTES
 331  *
 332  * MSDN is wrong when it says that hkey must be opened with the DELETE access
 333  * right. In reality, it opens a new handle with DELETE access.
 334  *
 335  * RETURNS
 336  *  Success: ERROR_SUCCESS
 337  *  Failure: Error code
 338  */
 339 LSTATUS WINAPI RegDeleteKeyA( HKEY hkey, LPCSTR name )
 340 {
 341     return RegDeleteKeyExA( hkey, name, 0, 0 );
 342 }
 343
 344
 345 /******************************************************************************
 346  * RegSetValueW   [ADVAPI32.@]
 347  *
 348  * Sets the data for the default or unnamed value of a reg key.
 349  *
 350  * PARAMS
 351  *  hkey     [I] Handle to an open key.
 352  *  subkey   [I] Name of a subkey of hKey.
 353  *  type     [I] Type of information to store.
 354  *  data     [I] String that contains the data to set for the default value.
 355  *  count    [I] Ignored.
 356  *
 357  * RETURNS
 358  *  Success: ERROR_SUCCESS
 359  *  Failure: nonzero error code from Winerror.h
 360  */
 361 LSTATUS WINAPI RegSetValueW( HKEY hkey, LPCWSTR subkey, DWORD type, LPCWSTR data, DWORD count )
 362 {
 363     TRACE("(%p,%s,%ld,%s,%ld)\n", hkey, debugstr_w(subkey), type, debugstr_w(data), count );
 364
 365     if (type != REG_SZ || !data) return ERROR_INVALID_PARAMETER;
 366
 367     return RegSetKeyValueW( hkey, subkey, NULL, type, data, (lstrlenW(data) + 1)*sizeof(WCHAR) );
 368 }
 369
 370 /******************************************************************************
 371  * RegSetValueA   [ADVAPI32.@]
 372  *
 373  * See RegSetValueW.
 374  */
 375 LSTATUS WINAPI RegSetValueA( HKEY hkey, LPCSTR subkey, DWORD type, LPCSTR data, DWORD count )
 376 {
 377     TRACE("(%p,%s,%ld,%s,%ld)\n", hkey, debugstr_a(subkey), type, debugstr_a(data), count );
 378
 379     if (type != REG_SZ || !data) return ERROR_INVALID_PARAMETER;
 380
 381     return RegSetKeyValueA( hkey, subkey, NULL, type, data, strlen(data) + 1 );
 382 }
 383
 384
 385 /******************************************************************************
 386  * RegQueryValueW   [ADVAPI32.@]
 387  *
 388  * Retrieves the data associated with the default or unnamed value of a key.
 389  *
 390  * PARAMS
 391  *  hkey      [I] Handle to an open key.
 392  *  name      [I] Name of the subkey of hKey.
 393  *  data      [O] Receives the string associated with the default value
 394  *                of the key.
 395  *  count     [I/O] Size of lpValue in bytes.
 396  *
 397  *  RETURNS
 398  *   Success: ERROR_SUCCESS
 399  *   Failure: nonzero error code from Winerror.h
 400  */
 401 LSTATUS WINAPI RegQueryValueW( HKEY hkey, LPCWSTR name, LPWSTR data, LPLONG count )
 402 {
 403     DWORD ret;
 404     HKEY subkey = hkey;
 405
 406     TRACE("(%p,%s,%p,%ld)\n", hkey, debugstr_w(name), data, count ? *count : 0 );
 407
 408     if (name && name[0])
 409     {
 410         if ((ret = RegOpenKeyW( hkey, name, &subkey )) != ERROR_SUCCESS) return ret;
 411     }
 412     ret = RegQueryValueExW( subkey, NULL, NULL, NULL, (LPBYTE)data, (LPDWORD)count );
 413     if (subkey != hkey) RegCloseKey( subkey );
 414     if (ret == ERROR_FILE_NOT_FOUND)
 415     {
 416         /* return empty string if default value not found */
 417         if (data) *data = 0;
 418         if (count) *count = sizeof(WCHAR);
 419         ret = ERROR_SUCCESS;
 420     }
 421     return ret;
 422 }
 423
 424
 425 /******************************************************************************
 426  * RegQueryValueA   [ADVAPI32.@]
 427  *
 428  * See RegQueryValueW.
 429  */
 430 LSTATUS WINAPI RegQueryValueA( HKEY hkey, LPCSTR name, LPSTR data, LPLONG count )
 431 {
 432     DWORD ret;
 433     HKEY subkey = hkey;
 434
 435     TRACE("(%p,%s,%p,%ld)\n", hkey, debugstr_a(name), data, count ? *count : 0 );
 436
 437     if (name && name[0])
 438     {
 439         if ((ret = RegOpenKeyA( hkey, name, &subkey )) != ERROR_SUCCESS) return ret;
 440     }
 441     ret = RegQueryValueExA( subkey, NULL, NULL, NULL, (LPBYTE)data, (LPDWORD)count );
 442     if (subkey != hkey) RegCloseKey( subkey );
 443     if (ret == ERROR_FILE_NOT_FOUND)
 444     {
 445         /* return empty string if default value not found */
 446         if (data) *data = 0;
 447         if (count) *count = 1;
 448         ret = ERROR_SUCCESS;
 449     }
 450     return ret;
 451 }
 452
 453
 454 /******************************************************************************
 455  * RegSaveKeyW   [ADVAPI32.@]
 456  *
 457  * Save a key and all of its subkeys and values to a new file in the standard format.
 458  *
 459  * PARAMS
 460  *  hkey   [I] Handle of key where save begins
 461  *  lpFile [I] Address of filename to save to
 462  *  sa     [I] Address of security structure
 463  *
 464  * RETURNS
 465  *  Success: ERROR_SUCCESS
 466  *  Failure: nonzero error code from Winerror.h
 467  */
 468 LSTATUS WINAPI RegSaveKeyW( HKEY hkey, LPCWSTR file, LPSECURITY_ATTRIBUTES sa )
 469 {
 470     return RegSaveKeyExW(hkey, file, sa, 0);
 471 }
 472
 473
 474 /******************************************************************************
 475  * RegSaveKeyA  [ADVAPI32.@]
 476  *
 477  * See RegSaveKeyW.
 478  */
 479 LSTATUS WINAPI RegSaveKeyA( HKEY hkey, LPCSTR file, LPSECURITY_ATTRIBUTES sa )
 480 {
 481     return RegSaveKeyExA(hkey, file, sa, 0);
 482 }
 483
 484
 485 /******************************************************************************
 486  * RegReplaceKeyW [ADVAPI32.@]
 487  *
 488  * Replace the file backing a registry key and all its subkeys with another file.
 489  *
 490  * PARAMS
 491  *  hkey      [I] Handle of open key
 492  *  lpSubKey  [I] Address of name of subkey
 493  *  lpNewFile [I] Address of filename for file with new data
 494  *  lpOldFile [I] Address of filename for backup file
 495  *
 496  * RETURNS
 497  *  Success: ERROR_SUCCESS
 498  *  Failure: nonzero error code from Winerror.h
 499  */
 500 LSTATUS WINAPI RegReplaceKeyW( HKEY hkey, LPCWSTR lpSubKey, LPCWSTR lpNewFile,
 501                                LPCWSTR lpOldFile )
 502 {
 503     FIXME("(%p,%s,%s,%s): stub\n", hkey, debugstr_w(lpSubKey),
 504           debugstr_w(lpNewFile),debugstr_w(lpOldFile));
 505     return ERROR_SUCCESS;
 506 }
 507
 508
 509 /******************************************************************************
 510  * RegRenameKey [ADVAPI32.@]
 511  *
 512  */
 513 LSTATUS WINAPI RegRenameKey( HKEY hkey, LPCWSTR subkey_name, LPCWSTR new_name )
 514 {
 515     UNICODE_STRING str;
 516     LSTATUS ret;
 517     HKEY subkey;
 518
 519     TRACE("%p, %s, %s.\n", hkey, debugstr_w(subkey_name), debugstr_w(new_name));
 520
 521     RtlInitUnicodeString(&str, new_name);
 522
 523     if (!subkey_name)
 524         return RtlNtStatusToDosError( NtRenameKey( hkey, &str ));
 525
 526     if ((ret = RegOpenKeyExW( hkey, subkey_name, 0, KEY_WRITE, &subkey )))
 527         return ret;
 528
 529     ret = RtlNtStatusToDosError( NtRenameKey( subkey, &str ));
 530     RegCloseKey( subkey );
 531
 532     return ret;
 533 }
 534
 535
 536 /******************************************************************************
 537  * RegReplaceKeyA [ADVAPI32.@]
 538  *
 539  * See RegReplaceKeyW.
 540  */
 541 LSTATUS WINAPI RegReplaceKeyA( HKEY hkey, LPCSTR lpSubKey, LPCSTR lpNewFile,
 542                                LPCSTR lpOldFile )
 543 {
 544     UNICODE_STRING lpSubKeyW;
 545     UNICODE_STRING lpNewFileW;
 546     UNICODE_STRING lpOldFileW;
 547     LONG ret;
 548
 549     RtlCreateUnicodeStringFromAsciiz( &lpSubKeyW, lpSubKey );
 550     RtlCreateUnicodeStringFromAsciiz( &lpOldFileW, lpOldFile );
 551     RtlCreateUnicodeStringFromAsciiz( &lpNewFileW, lpNewFile );
 552     ret = RegReplaceKeyW( hkey, lpSubKeyW.Buffer, lpNewFileW.Buffer, lpOldFileW.Buffer );
 553     RtlFreeUnicodeString( &lpOldFileW );
 554     RtlFreeUnicodeString( &lpNewFileW );
 555     RtlFreeUnicodeString( &lpSubKeyW );
 556     return ret;
 557 }
 558
 559
 560 /******************************************************************************
 561  * RegConnectRegistryW [ADVAPI32.@]
 562  *
 563  * Establish a connection to a predefined registry key on another computer.
 564  *
 565  * PARAMS
 566  *  lpMachineName [I] Address of name of remote computer
 567  *  hHey          [I] Predefined registry handle
 568  *  phkResult     [I] Address of buffer for remote registry handle
 569  *
 570  * RETURNS
 571  *  Success: ERROR_SUCCESS
 572  *  Failure: nonzero error code from Winerror.h
 573  */
 574 LSTATUS WINAPI RegConnectRegistryW( LPCWSTR lpMachineName, HKEY hKey,
 575                                     PHKEY phkResult )
 576 {
 577     LONG ret;
 578
 579     TRACE("(%s,%p,%p)\n",debugstr_w(lpMachineName), hKey, phkResult);
 580
 581     if (!lpMachineName || !*lpMachineName) {
 582         /* Use the local machine name */
 583         ret = RegOpenKeyW( hKey, NULL, phkResult );
 584     }
 585     else {
 586         WCHAR compName[MAX_COMPUTERNAME_LENGTH + 1];
 587         DWORD len = ARRAY_SIZE( compName );
 588
 589         /* MSDN says lpMachineName must start with \\ : not so */
 590         if( lpMachineName[0] == '\\' &&  lpMachineName[1] == '\\')
 591             lpMachineName += 2;
 592         if (GetComputerNameW(compName, &len))
 593         {
 594             if (!wcsicmp(lpMachineName, compName))
 595                 ret = RegOpenKeyW(hKey, NULL, phkResult);
 596             else
 597             {
 598                 FIXME("Connect to %s is not supported.\n",debugstr_w(lpMachineName));
 599                 ret = ERROR_BAD_NETPATH;
 600             }
 601         }
 602         else
 603             ret = GetLastError();
 604     }
 605     return ret;
 606 }
 607
 608
 609 /******************************************************************************
 610  * RegConnectRegistryA [ADVAPI32.@]
 611  *
 612  * See RegConnectRegistryW.
 613  */
 614 LSTATUS WINAPI RegConnectRegistryA( LPCSTR machine, HKEY hkey, PHKEY reskey )
 615 {
 616     UNICODE_STRING machineW;
 617     LONG ret;
 618
 619     RtlCreateUnicodeStringFromAsciiz( &machineW, machine );
 620     ret = RegConnectRegistryW( machineW.Buffer, hkey, reskey );
 621     RtlFreeUnicodeString( &machineW );
 622     return ret;
 623 }
 624
 625
 626 /******************************************************************************
 627  * RegDisablePredefinedCache [ADVAPI32.@]
 628  *
 629  * Disables the caching of the HKEY_CURRENT_USER key for the process.
 630  *
 631  * PARAMS
 632  *  None.
 633  *
 634  * RETURNS
 635  *  Success: ERROR_SUCCESS
 636  *  Failure: nonzero error code from Winerror.h
 637  *
 638  * NOTES
 639  *  This is useful for services that use impersonation.
 640  */
 641 LSTATUS WINAPI RegDisablePredefinedCache(void)
 642 {
 643     return RtlNtStatusToDosError( DisablePredefinedHandleTableInternal( HKEY_CURRENT_USER ));
 644 }
 645
 646
 647 /******************************************************************************
 648  * RegCopyTreeA [ADVAPI32.@]
 649  *
 650  */
 651 LONG WINAPI RegCopyTreeA( HKEY hsrc, const char *subkey, HKEY hdst )
 652 {
 653     UNICODE_STRING subkeyW;
 654     LONG ret;
 655
 656     if (subkey) RtlCreateUnicodeStringFromAsciiz( &subkeyW, subkey );
 657     else subkeyW.Buffer = NULL;
 658     ret = RegCopyTreeW( hsrc, subkeyW.Buffer, hdst );
 659     RtlFreeUnicodeString( &subkeyW );
 660     return ret;
 661 }
 662
 663
 664 /******************************************************************************
 665  * RegEnableReflectionKey [ADVAPI32.@]
 666  *
 667  */
 668 LONG WINAPI RegEnableReflectionKey(HKEY base)
 669 {
 670     FIXME("%p: stub\n", base);
 671     return ERROR_CALL_NOT_IMPLEMENTED;
 672 }
 673
 674
 675 /******************************************************************************
 676  * RegDisableReflectionKey [ADVAPI32.@]
 677  *
 678  */
 679 LONG WINAPI RegDisableReflectionKey(HKEY base)
 680 {
 681     FIXME("%p: stub\n", base);
 682     return ERROR_SUCCESS;
 683 }