2000-07-25 17:10:52 +02:00
/*
* Registry management
*
* Copyright ( C ) 1999 Alexandre Julliard
*
* Based on misc / registry . c code
* Copyright ( C ) 1996 Marcus Meissner
* Copyright ( C ) 1998 Matthew Becker
* Copyright ( C ) 1999 Sylvain St - Germain
*
* This file is concerned about handle management and interaction with the Wine server .
* Registry file I / O is in misc / registry . c .
*/
# include <stdlib.h>
# include <stdio.h>
# include <unistd.h>
# include "winbase.h"
# include "winreg.h"
# include "winerror.h"
# include "wine/winbase16.h"
2000-08-14 16:41:19 +02:00
# include "wine/unicode.h"
2000-09-26 01:30:56 +02:00
# include "wine/winestring.h"
2000-07-25 17:10:52 +02:00
# include "heap.h"
# include "server.h"
# include "debugtools.h"
DEFAULT_DEBUG_CHANNEL ( reg ) ;
/* Unicode->Ansi conversion without string delimiters */
static LPSTR memcpyWtoA ( LPSTR dst , LPCWSTR src , INT n )
{
LPSTR p = dst ;
while ( n - - > 0 ) * p + + = ( CHAR ) * src + + ;
return dst ;
}
/* check if value type needs string conversion (Ansi<->Unicode) */
static inline int is_string ( DWORD type )
{
return ( type = = REG_SZ ) | | ( type = = REG_EXPAND_SZ ) | | ( type = = REG_MULTI_SZ ) ;
}
/* copy a key name into the request buffer */
static inline DWORD copy_nameW ( LPWSTR dest , LPCWSTR name )
{
if ( name )
{
2000-08-14 16:41:19 +02:00
if ( strlenW ( name ) > MAX_PATH ) return ERROR_MORE_DATA ;
strcpyW ( dest , name ) ;
2000-07-25 17:10:52 +02:00
}
else dest [ 0 ] = 0 ;
return ERROR_SUCCESS ;
}
/* copy a key name into the request buffer */
static inline DWORD copy_nameAtoW ( LPWSTR dest , LPCSTR name )
{
if ( name )
{
if ( strlen ( name ) > MAX_PATH ) return ERROR_MORE_DATA ;
lstrcpyAtoW ( dest , name ) ;
}
else dest [ 0 ] = 0 ;
return ERROR_SUCCESS ;
}
/* do a server call without setting the last error code */
static inline int reg_server_call ( enum request req )
{
unsigned int res = server_call_noerr ( req ) ;
if ( res ) res = RtlNtStatusToDosError ( res ) ;
return res ;
}
/******************************************************************************
* RegCreateKeyExW [ ADVAPI32 .131 ]
*
* PARAMS
* hkey [ I ] Handle of an open key
* name [ I ] Address of subkey name
* reserved [ I ] Reserved - must be 0
* class [ I ] Address of class string
* options [ I ] Special options flag
* access [ I ] Desired security access
* sa [ I ] Address of key security structure
* retkey [ O ] Address of buffer for opened handle
* dispos [ O ] Receives REG_CREATED_NEW_KEY or REG_OPENED_EXISTING_KEY
*
* NOTES
* in case of failing retkey remains untouched
*/
DWORD WINAPI RegCreateKeyExW ( HKEY hkey , LPCWSTR name , DWORD reserved , LPWSTR class ,
DWORD options , REGSAM access , SECURITY_ATTRIBUTES * sa ,
LPHKEY retkey , LPDWORD dispos )
{
2000-10-01 03:44:50 +02:00
OBJECT_ATTRIBUTES attr ;
UNICODE_STRING nameW , classW ;
2000-07-25 17:10:52 +02:00
if ( reserved ) return ERROR_INVALID_PARAMETER ;
if ( ! ( access & KEY_ALL_ACCESS ) | | ( access & ~ KEY_ALL_ACCESS ) ) return ERROR_ACCESS_DENIED ;
2000-10-01 03:44:50 +02:00
attr . Length = sizeof ( attr ) ;
attr . RootDirectory = hkey ;
attr . ObjectName = & nameW ;
attr . Attributes = 0 ;
attr . SecurityDescriptor = NULL ;
attr . SecurityQualityOfService = NULL ;
RtlInitUnicodeString ( & nameW , name ) ;
RtlInitUnicodeString ( & classW , class ) ;
return RtlNtStatusToDosError ( NtCreateKey ( retkey , access , & attr , 0 ,
& classW , options , dispos ) ) ;
2000-07-25 17:10:52 +02:00
}
/******************************************************************************
* RegCreateKeyExA [ ADVAPI32 .130 ]
*/
DWORD WINAPI RegCreateKeyExA ( HKEY hkey , LPCSTR name , DWORD reserved , LPSTR class ,
DWORD options , REGSAM access , SECURITY_ATTRIBUTES * sa ,
LPHKEY retkey , LPDWORD dispos )
{
2000-10-01 03:44:50 +02:00
OBJECT_ATTRIBUTES attr ;
UNICODE_STRING nameW , classW ;
ANSI_STRING nameA , classA ;
NTSTATUS status ;
2000-07-25 17:10:52 +02:00
if ( reserved ) return ERROR_INVALID_PARAMETER ;
if ( ! ( access & KEY_ALL_ACCESS ) | | ( access & ~ KEY_ALL_ACCESS ) ) return ERROR_ACCESS_DENIED ;
2000-10-01 03:44:50 +02:00
attr . Length = sizeof ( attr ) ;
attr . RootDirectory = hkey ;
attr . ObjectName = & nameW ;
attr . Attributes = 0 ;
attr . SecurityDescriptor = NULL ;
attr . SecurityQualityOfService = NULL ;
RtlInitAnsiString ( & nameA , name ) ;
RtlInitAnsiString ( & classA , class ) ;
/* FIXME: should use Unicode buffer in TEB */
if ( ! ( status = RtlAnsiStringToUnicodeString ( & nameW , & nameA , TRUE ) ) )
2000-07-25 17:10:52 +02:00
{
2000-10-01 03:44:50 +02:00
if ( ! ( status = RtlAnsiStringToUnicodeString ( & classW , & classA , TRUE ) ) )
{
status = NtCreateKey ( retkey , access , & attr , 0 , & classW , options , dispos ) ;
RtlFreeUnicodeString ( & classW ) ;
}
RtlFreeUnicodeString ( & nameW ) ;
2000-07-25 17:10:52 +02:00
}
2000-10-01 03:44:50 +02:00
return RtlNtStatusToDosError ( status ) ;
2000-07-25 17:10:52 +02:00
}
/******************************************************************************
* RegCreateKeyW [ ADVAPI32 .132 ]
*/
DWORD WINAPI RegCreateKeyW ( HKEY hkey , LPCWSTR name , LPHKEY retkey )
{
/* FIXME: previous implementation converted ERROR_INVALID_HANDLE to ERROR_BADKEY, */
/* but at least my version of NT (4.0 SP5) doesn't do this. -- AJ */
return RegCreateKeyExW ( hkey , name , 0 , NULL , REG_OPTION_NON_VOLATILE ,
KEY_ALL_ACCESS , NULL , retkey , NULL ) ;
}
/******************************************************************************
* RegCreateKeyA [ ADVAPI32 .129 ]
*/
DWORD WINAPI RegCreateKeyA ( HKEY hkey , LPCSTR name , LPHKEY retkey )
{
return RegCreateKeyExA ( hkey , name , 0 , NULL , REG_OPTION_NON_VOLATILE ,
KEY_ALL_ACCESS , NULL , retkey , NULL ) ;
}
/******************************************************************************
* RegOpenKeyExW [ ADVAPI32 .150 ]
*
* Opens the specified key
*
* Unlike RegCreateKeyEx , this does not create the key if it does not exist .
*
* PARAMS
* hkey [ I ] Handle of open key
* name [ I ] Name of subkey to open
* reserved [ I ] Reserved - must be zero
* access [ I ] Security access mask
* retkey [ O ] Handle to open key
*
* RETURNS
* Success : ERROR_SUCCESS
* Failure : Error code
*
* NOTES
* in case of failing is retkey = 0
*/
DWORD WINAPI RegOpenKeyExW ( HKEY hkey , LPCWSTR name , DWORD reserved , REGSAM access , LPHKEY retkey )
{
2000-10-01 03:44:50 +02:00
OBJECT_ATTRIBUTES attr ;
UNICODE_STRING nameW ;
attr . Length = sizeof ( attr ) ;
attr . RootDirectory = hkey ;
attr . ObjectName = & nameW ;
attr . Attributes = 0 ;
attr . SecurityDescriptor = NULL ;
attr . SecurityQualityOfService = NULL ;
RtlInitUnicodeString ( & nameW , name ) ;
return RtlNtStatusToDosError ( NtOpenKey ( retkey , access , & attr ) ) ;
2000-07-25 17:10:52 +02:00
}
/******************************************************************************
* RegOpenKeyExA [ ADVAPI32 .149 ]
*/
DWORD WINAPI RegOpenKeyExA ( HKEY hkey , LPCSTR name , DWORD reserved , REGSAM access , LPHKEY retkey )
{
2000-10-01 03:44:50 +02:00
OBJECT_ATTRIBUTES attr ;
UNICODE_STRING nameW ;
STRING nameA ;
NTSTATUS status ;
attr . Length = sizeof ( attr ) ;
attr . RootDirectory = hkey ;
attr . ObjectName = & nameW ;
attr . Attributes = 0 ;
attr . SecurityDescriptor = NULL ;
attr . SecurityQualityOfService = NULL ;
RtlInitAnsiString ( & nameA , name ) ;
/* FIXME: should use Unicode buffer in TEB */
if ( ! ( status = RtlAnsiStringToUnicodeString ( & nameW , & nameA , TRUE ) ) )
{
status = NtOpenKey ( retkey , access , & attr ) ;
RtlFreeUnicodeString ( & nameW ) ;
}
return RtlNtStatusToDosError ( status ) ;
2000-07-25 17:10:52 +02:00
}
/******************************************************************************
* RegOpenKeyW [ ADVAPI32 .151 ]
*
* PARAMS
* hkey [ I ] Handle of open key
* name [ I ] Address of name of subkey to open
* retkey [ O ] Handle to open key
*
* RETURNS
* Success : ERROR_SUCCESS
* Failure : Error code
*
* NOTES
* in case of failing is retkey = 0
*/
DWORD WINAPI RegOpenKeyW ( HKEY hkey , LPCWSTR name , LPHKEY retkey )
{
return RegOpenKeyExW ( hkey , name , 0 , KEY_ALL_ACCESS , retkey ) ;
}
/******************************************************************************
* RegOpenKeyA [ ADVAPI32 .148 ]
*/
DWORD WINAPI RegOpenKeyA ( HKEY hkey , LPCSTR name , LPHKEY retkey )
{
return RegOpenKeyExA ( hkey , name , 0 , KEY_ALL_ACCESS , retkey ) ;
}
/******************************************************************************
* RegEnumKeyExW [ ADVAPI32 .139 ]
*
* PARAMS
* hkey [ I ] Handle to key to enumerate
* index [ I ] Index of subkey to enumerate
* name [ O ] Buffer for subkey name
* name_len [ O ] Size of subkey buffer
* reserved [ I ] Reserved
* class [ O ] Buffer for class string
* class_len [ O ] Size of class buffer
* ft [ O ] Time key last written to
*/
DWORD WINAPI RegEnumKeyExW ( HKEY hkey , DWORD index , LPWSTR name , LPDWORD name_len ,
LPDWORD reserved , LPWSTR class , LPDWORD class_len , FILETIME * ft )
{
2000-10-02 05:46:58 +02:00
NTSTATUS status ;
char buffer [ 256 ] , * buf_ptr = buffer ;
KEY_NODE_INFORMATION * info = ( KEY_NODE_INFORMATION * ) buffer ;
DWORD total_size ;
2000-07-25 17:10:52 +02:00
TRACE ( " (0x%x,%ld,%p,%p(%ld),%p,%p,%p,%p) \n " , hkey , index , name , name_len ,
name_len ? * name_len : - 1 , reserved , class , class_len , ft ) ;
if ( reserved ) return ERROR_INVALID_PARAMETER ;
2000-10-02 05:46:58 +02:00
status = NtEnumerateKey ( hkey , index , KeyNodeInformation ,
buffer , sizeof ( buffer ) , & total_size ) ;
2000-07-25 17:10:52 +02:00
2000-10-02 05:46:58 +02:00
while ( status = = STATUS_BUFFER_OVERFLOW )
{
/* retry with a dynamically allocated buffer */
if ( buf_ptr ! = buffer ) HeapFree ( GetProcessHeap ( ) , 0 , buf_ptr ) ;
if ( ! ( buf_ptr = HeapAlloc ( GetProcessHeap ( ) , 0 , total_size ) ) )
return ERROR_NOT_ENOUGH_MEMORY ;
info = ( KEY_NODE_INFORMATION * ) buf_ptr ;
status = NtEnumerateKey ( hkey , index , KeyNodeInformation ,
buf_ptr , total_size , & total_size ) ;
}
2000-07-25 17:10:52 +02:00
2000-10-02 05:46:58 +02:00
if ( ! status )
2000-07-25 17:10:52 +02:00
{
2000-10-02 05:46:58 +02:00
DWORD len = info - > NameLength / sizeof ( WCHAR ) ;
DWORD cls_len = info - > ClassLength / sizeof ( WCHAR ) ;
if ( ft ) * ft = info - > LastWriteTime ;
if ( len > = * name_len | | ( class_len & & ( cls_len > = * class_len ) ) )
status = STATUS_BUFFER_OVERFLOW ;
else
{
* name_len = len ;
memcpy ( name , info - > Name , info - > NameLength ) ;
name [ len ] = 0 ;
if ( class_len )
{
* class_len = cls_len ;
if ( class )
{
memcpy ( class , buf_ptr + info - > ClassOffset , info - > ClassLength ) ;
class [ cls_len ] = 0 ;
}
}
}
2000-07-25 17:10:52 +02:00
}
2000-10-02 05:46:58 +02:00
if ( buf_ptr ! = buffer ) HeapFree ( GetProcessHeap ( ) , 0 , buf_ptr ) ;
return RtlNtStatusToDosError ( status ) ;
2000-07-25 17:10:52 +02:00
}
/******************************************************************************
* RegEnumKeyExA [ ADVAPI32 .138 ]
*/
DWORD WINAPI RegEnumKeyExA ( HKEY hkey , DWORD index , LPSTR name , LPDWORD name_len ,
LPDWORD reserved , LPSTR class , LPDWORD class_len , FILETIME * ft )
{
2000-10-02 05:46:58 +02:00
NTSTATUS status ;
char buffer [ 256 ] , * buf_ptr = buffer ;
KEY_NODE_INFORMATION * info = ( KEY_NODE_INFORMATION * ) buffer ;
DWORD total_size ;
2000-07-25 17:10:52 +02:00
TRACE ( " (0x%x,%ld,%p,%p(%ld),%p,%p,%p,%p) \n " , hkey , index , name , name_len ,
name_len ? * name_len : - 1 , reserved , class , class_len , ft ) ;
if ( reserved ) return ERROR_INVALID_PARAMETER ;
2000-10-02 05:46:58 +02:00
status = NtEnumerateKey ( hkey , index , KeyNodeInformation ,
buffer , sizeof ( buffer ) , & total_size ) ;
2000-07-25 17:10:52 +02:00
2000-10-02 05:46:58 +02:00
while ( status = = STATUS_BUFFER_OVERFLOW )
{
/* retry with a dynamically allocated buffer */
if ( buf_ptr ! = buffer ) HeapFree ( GetProcessHeap ( ) , 0 , buf_ptr ) ;
if ( ! ( buf_ptr = HeapAlloc ( GetProcessHeap ( ) , 0 , total_size ) ) )
return ERROR_NOT_ENOUGH_MEMORY ;
info = ( KEY_NODE_INFORMATION * ) buf_ptr ;
status = NtEnumerateKey ( hkey , index , KeyNodeInformation ,
buf_ptr , total_size , & total_size ) ;
}
2000-07-25 17:10:52 +02:00
2000-10-02 05:46:58 +02:00
if ( ! status )
2000-07-25 17:10:52 +02:00
{
2000-10-02 05:46:58 +02:00
DWORD len = WideCharToMultiByte ( CP_ACP , 0 , info - > Name , info - > NameLength / sizeof ( WCHAR ) ,
NULL , 0 , NULL , NULL ) ;
DWORD cls_len = WideCharToMultiByte ( CP_ACP , 0 , ( WCHAR * ) ( buf_ptr + info - > ClassOffset ) ,
info - > ClassLength / sizeof ( WCHAR ) ,
NULL , 0 , NULL , NULL ) ;
if ( ft ) * ft = info - > LastWriteTime ;
if ( len > = * name_len | | ( class_len & & ( cls_len > = * class_len ) ) )
status = STATUS_BUFFER_OVERFLOW ;
else
{
* name_len = len ;
WideCharToMultiByte ( CP_ACP , 0 , info - > Name , info - > NameLength / sizeof ( WCHAR ) ,
name , len , NULL , NULL ) ;
name [ len ] = 0 ;
if ( class_len )
{
* class_len = cls_len ;
if ( class )
{
WideCharToMultiByte ( CP_ACP , 0 , ( WCHAR * ) ( buf_ptr + info - > ClassOffset ) ,
info - > ClassLength / sizeof ( WCHAR ) ,
class , cls_len , NULL , NULL ) ;
class [ cls_len ] = 0 ;
}
}
}
2000-07-25 17:10:52 +02:00
}
2000-10-02 05:46:58 +02:00
if ( buf_ptr ! = buffer ) HeapFree ( GetProcessHeap ( ) , 0 , buf_ptr ) ;
return RtlNtStatusToDosError ( status ) ;
2000-07-25 17:10:52 +02:00
}
/******************************************************************************
* RegEnumKeyW [ ADVAPI32 .140 ]
*/
DWORD WINAPI RegEnumKeyW ( HKEY hkey , DWORD index , LPWSTR name , DWORD name_len )
{
return RegEnumKeyExW ( hkey , index , name , & name_len , NULL , NULL , NULL , NULL ) ;
}
/******************************************************************************
* RegEnumKeyA [ ADVAPI32 .137 ]
*/
DWORD WINAPI RegEnumKeyA ( HKEY hkey , DWORD index , LPSTR name , DWORD name_len )
{
return RegEnumKeyExA ( hkey , index , name , & name_len , NULL , NULL , NULL , NULL ) ;
}
/******************************************************************************
* RegQueryInfoKeyW [ ADVAPI32 .153 ]
*
* PARAMS
* hkey [ I ] Handle to key to query
* class [ O ] Buffer for class string
* class_len [ O ] Size of class string buffer
* reserved [ I ] Reserved
* subkeys [ O ] Buffer for number of subkeys
* max_subkey [ O ] Buffer for longest subkey name length
* max_class [ O ] Buffer for longest class string length
* values [ O ] Buffer for number of value entries
* max_value [ O ] Buffer for longest value name length
* max_data [ O ] Buffer for longest value data length
* security [ O ] Buffer for security descriptor length
* modif [ O ] Modification time
*
* - win95 allows class to be valid and class_len to be NULL
* - winnt returns ERROR_INVALID_PARAMETER if class is valid and class_len is NULL
* - both allow class to be NULL and class_len to be NULL
* ( it ' s hard to test validity , so test ! NULL instead )
*/
DWORD WINAPI RegQueryInfoKeyW ( HKEY hkey , LPWSTR class , LPDWORD class_len , LPDWORD reserved ,
LPDWORD subkeys , LPDWORD max_subkey , LPDWORD max_class ,
LPDWORD values , LPDWORD max_value , LPDWORD max_data ,
LPDWORD security , FILETIME * modif )
{
2000-10-02 05:46:58 +02:00
NTSTATUS status ;
char buffer [ 256 ] , * buf_ptr = buffer ;
KEY_FULL_INFORMATION * info = ( KEY_FULL_INFORMATION * ) buffer ;
DWORD total_size ;
2000-07-25 17:10:52 +02:00
TRACE ( " (0x%x,%p,%ld,%p,%p,%p,%p,%p,%p,%p,%p) \n " , hkey , class , class_len ? * class_len : 0 ,
reserved , subkeys , max_subkey , values , max_value , max_data , security , modif ) ;
2000-08-14 16:41:19 +02:00
if ( class & & ! class_len & & ! ( GetVersion ( ) & 0x80000000 /*NT*/ ) )
2000-07-25 17:10:52 +02:00
return ERROR_INVALID_PARAMETER ;
2000-10-02 05:46:58 +02:00
status = NtQueryKey ( hkey , KeyFullInformation , buffer , sizeof ( buffer ) , & total_size ) ;
2000-07-25 17:10:52 +02:00
if ( class )
{
2000-10-02 05:46:58 +02:00
/* retry with a dynamically allocated buffer */
while ( status = = STATUS_BUFFER_OVERFLOW )
2000-07-25 17:10:52 +02:00
{
2000-10-02 05:46:58 +02:00
if ( buf_ptr ! = buffer ) HeapFree ( GetProcessHeap ( ) , 0 , buf_ptr ) ;
if ( ! ( buf_ptr = HeapAlloc ( GetProcessHeap ( ) , 0 , total_size ) ) )
return ERROR_NOT_ENOUGH_MEMORY ;
info = ( KEY_FULL_INFORMATION * ) buf_ptr ;
status = NtQueryKey ( hkey , KeyFullInformation , buf_ptr , total_size , & total_size ) ;
}
if ( ! status )
{
if ( class_len & & ( info - > ClassLength / sizeof ( WCHAR ) + 1 > * class_len ) )
{
status = STATUS_BUFFER_OVERFLOW ;
}
else
{
memcpy ( class , buf_ptr + info - > ClassOffset , info - > ClassLength ) ;
class [ info - > ClassLength / sizeof ( WCHAR ) ] = 0 ;
}
2000-07-25 17:10:52 +02:00
}
}
2000-10-02 05:46:58 +02:00
if ( ! status | | status = = STATUS_BUFFER_OVERFLOW )
{
if ( class_len ) * class_len = info - > ClassLength / sizeof ( WCHAR ) ;
if ( subkeys ) * subkeys = info - > SubKeys ;
if ( max_subkey ) * max_subkey = info - > MaxNameLen ;
if ( max_class ) * max_class = info - > MaxClassLen ;
if ( values ) * values = info - > Values ;
if ( max_value ) * max_value = info - > MaxValueNameLen ;
if ( max_data ) * max_data = info - > MaxValueDataLen ;
if ( modif ) * modif = info - > LastWriteTime ;
}
if ( buf_ptr ! = buffer ) HeapFree ( GetProcessHeap ( ) , 0 , buf_ptr ) ;
return RtlNtStatusToDosError ( status ) ;
2000-07-25 17:10:52 +02:00
}
/******************************************************************************
* RegQueryInfoKeyA [ ADVAPI32 .152 ]
*/
DWORD WINAPI RegQueryInfoKeyA ( HKEY hkey , LPSTR class , LPDWORD class_len , LPDWORD reserved ,
LPDWORD subkeys , LPDWORD max_subkey , LPDWORD max_class ,
LPDWORD values , LPDWORD max_value , LPDWORD max_data ,
LPDWORD security , FILETIME * modif )
{
2000-10-02 05:46:58 +02:00
NTSTATUS status ;
char buffer [ 256 ] , * buf_ptr = buffer ;
KEY_FULL_INFORMATION * info = ( KEY_FULL_INFORMATION * ) buffer ;
DWORD total_size ;
2000-07-25 17:10:52 +02:00
TRACE ( " (0x%x,%p,%ld,%p,%p,%p,%p,%p,%p,%p,%p) \n " , hkey , class , class_len ? * class_len : 0 ,
reserved , subkeys , max_subkey , values , max_value , max_data , security , modif ) ;
2000-08-14 16:41:19 +02:00
if ( class & & ! class_len & & ! ( GetVersion ( ) & 0x80000000 /*NT*/ ) )
2000-07-25 17:10:52 +02:00
return ERROR_INVALID_PARAMETER ;
2000-10-02 05:46:58 +02:00
status = NtQueryKey ( hkey , KeyFullInformation , buffer , sizeof ( buffer ) , & total_size ) ;
2000-07-25 17:10:52 +02:00
2000-10-02 05:46:58 +02:00
if ( class | | class_len )
2000-07-25 17:10:52 +02:00
{
2000-10-02 05:46:58 +02:00
/* retry with a dynamically allocated buffer */
while ( status = = STATUS_BUFFER_OVERFLOW )
{
if ( buf_ptr ! = buffer ) HeapFree ( GetProcessHeap ( ) , 0 , buf_ptr ) ;
if ( ! ( buf_ptr = HeapAlloc ( GetProcessHeap ( ) , 0 , total_size ) ) )
return ERROR_NOT_ENOUGH_MEMORY ;
info = ( KEY_FULL_INFORMATION * ) buf_ptr ;
status = NtQueryKey ( hkey , KeyFullInformation , buf_ptr , total_size , & total_size ) ;
}
if ( ! status )
2000-07-25 17:10:52 +02:00
{
2000-10-02 05:46:58 +02:00
DWORD len = WideCharToMultiByte ( CP_ACP , 0 ,
( WCHAR * ) ( buf_ptr + info - > ClassOffset ) ,
info - > ClassLength / sizeof ( WCHAR ) ,
NULL , 0 , NULL , NULL ) ;
if ( class_len )
{
if ( len + 1 > * class_len ) status = STATUS_BUFFER_OVERFLOW ;
* class_len = len ;
}
if ( class & & ! status )
{
WideCharToMultiByte ( CP_ACP , 0 ,
( WCHAR * ) ( buf_ptr + info - > ClassOffset ) ,
info - > ClassLength / sizeof ( WCHAR ) ,
class , len , NULL , NULL ) ;
class [ len ] = 0 ;
}
2000-07-25 17:10:52 +02:00
}
}
2000-10-02 05:46:58 +02:00
if ( ! status | | status = = STATUS_BUFFER_OVERFLOW )
{
if ( subkeys ) * subkeys = info - > SubKeys ;
if ( max_subkey ) * max_subkey = info - > MaxNameLen ;
if ( max_class ) * max_class = info - > MaxClassLen ;
if ( values ) * values = info - > Values ;
if ( max_value ) * max_value = info - > MaxValueNameLen ;
if ( max_data ) * max_data = info - > MaxValueDataLen ;
if ( modif ) * modif = info - > LastWriteTime ;
}
if ( buf_ptr ! = buffer ) HeapFree ( GetProcessHeap ( ) , 0 , buf_ptr ) ;
return RtlNtStatusToDosError ( status ) ;
2000-07-25 17:10:52 +02:00
}
/******************************************************************************
* RegCloseKey [ ADVAPI32 .126 ]
*
* Releases the handle of the specified key
*
* PARAMS
* hkey [ I ] Handle of key to close
*
* RETURNS
* Success : ERROR_SUCCESS
* Failure : Error code
*/
DWORD WINAPI RegCloseKey ( HKEY hkey )
{
2000-10-01 03:44:50 +02:00
if ( ! hkey | | hkey > = 0x80000000 ) return ERROR_SUCCESS ;
return RtlNtStatusToDosError ( NtClose ( hkey ) ) ;
2000-07-25 17:10:52 +02:00
}
/******************************************************************************
* RegDeleteKeyW [ ADVAPI32 .134 ]
*
* PARAMS
* hkey [ I ] Handle to open key
* name [ I ] Name of subkey to delete
*
* RETURNS
* Success : ERROR_SUCCESS
* Failure : Error code
*/
DWORD WINAPI RegDeleteKeyW ( HKEY hkey , LPCWSTR name )
{
DWORD ret ;
2000-10-01 03:44:50 +02:00
HKEY tmp ;
2000-07-25 17:10:52 +02:00
2000-10-01 03:44:50 +02:00
if ( ! name | | ! * name ) return NtDeleteKey ( hkey ) ;
if ( ! ( ret = RegOpenKeyExW ( hkey , name , 0 , 0 , & tmp ) ) )
{
ret = RtlNtStatusToDosError ( NtDeleteKey ( tmp ) ) ;
RegCloseKey ( tmp ) ;
}
return ret ;
2000-07-25 17:10:52 +02:00
}
/******************************************************************************
* RegDeleteKeyA [ ADVAPI32 .133 ]
*/
DWORD WINAPI RegDeleteKeyA ( HKEY hkey , LPCSTR name )
{
DWORD ret ;
2000-10-01 03:44:50 +02:00
HKEY tmp ;
2000-07-25 17:10:52 +02:00
2000-10-01 03:44:50 +02:00
if ( ! name | | ! * name ) return NtDeleteKey ( hkey ) ;
if ( ! ( ret = RegOpenKeyExA ( hkey , name , 0 , 0 , & tmp ) ) )
{
ret = RtlNtStatusToDosError ( NtDeleteKey ( tmp ) ) ;
RegCloseKey ( tmp ) ;
}
return ret ;
2000-07-25 17:10:52 +02:00
}
/******************************************************************************
* RegSetValueExW [ ADVAPI32 .170 ]
*
* Sets the data and type of a value under a register key
*
* PARAMS
* hkey [ I ] Handle of key to set value for
* name [ I ] Name of value to set
* reserved [ I ] Reserved - must be zero
* type [ I ] Flag for value type
* data [ I ] Address of value data
* count [ I ] Size of value data
*
* RETURNS
* Success : ERROR_SUCCESS
* Failure : Error code
*
* NOTES
* win95 does not care about count for REG_SZ and finds out the len by itself ( js )
* NT does definitely care ( aj )
*/
DWORD WINAPI RegSetValueExW ( HKEY hkey , LPCWSTR name , DWORD reserved ,
DWORD type , CONST BYTE * data , DWORD count )
{
2000-10-01 03:44:50 +02:00
UNICODE_STRING nameW ;
2000-07-25 17:10:52 +02:00
2000-10-01 03:44:50 +02:00
if ( count & & is_string ( type ) )
2000-07-25 17:10:52 +02:00
{
LPCWSTR str = ( LPCWSTR ) data ;
/* if user forgot to count terminating null, add it (yes NT does this) */
if ( str [ count / sizeof ( WCHAR ) - 1 ] & & ! str [ count / sizeof ( WCHAR ) ] )
count + = sizeof ( WCHAR ) ;
}
2000-10-01 03:44:50 +02:00
RtlInitUnicodeString ( & nameW , name ) ;
return RtlNtStatusToDosError ( NtSetValueKey ( hkey , & nameW , 0 , type , data , count ) ) ;
2000-07-25 17:10:52 +02:00
}
/******************************************************************************
* RegSetValueExA [ ADVAPI32 .169 ]
*/
DWORD WINAPI RegSetValueExA ( HKEY hkey , LPCSTR name , DWORD reserved , DWORD type ,
2000-10-01 03:44:50 +02:00
CONST BYTE * data , DWORD count )
2000-07-25 17:10:52 +02:00
{
2000-10-01 03:44:50 +02:00
UNICODE_STRING nameW ;
ANSI_STRING nameA ;
WCHAR * dataW = NULL ;
NTSTATUS status ;
2000-07-25 17:10:52 +02:00
2000-10-01 03:44:50 +02:00
if ( count & & is_string ( type ) )
2000-07-25 17:10:52 +02:00
{
/* if user forgot to count terminating null, add it (yes NT does this) */
if ( data [ count - 1 ] & & ! data [ count ] ) count + + ;
}
2000-10-01 03:44:50 +02:00
if ( is_string ( type ) ) /* need to convert to Unicode */
2000-07-25 17:10:52 +02:00
{
2000-10-01 03:44:50 +02:00
DWORD lenW = MultiByteToWideChar ( CP_ACP , 0 , data , count , NULL , 0 ) ;
if ( ! ( dataW = HeapAlloc ( GetProcessHeap ( ) , 0 , lenW * sizeof ( WCHAR ) ) ) )
return ERROR_OUTOFMEMORY ;
MultiByteToWideChar ( CP_ACP , 0 , data , count , dataW , lenW ) ;
count = lenW * sizeof ( WCHAR ) ;
data = ( BYTE * ) dataW ;
}
2000-07-25 17:10:52 +02:00
2000-10-01 03:44:50 +02:00
RtlInitAnsiString ( & nameA , name ) ;
/* FIXME: should use Unicode buffer in TEB */
if ( ! ( status = RtlAnsiStringToUnicodeString ( & nameW , & nameA , TRUE ) ) )
{
status = NtSetValueKey ( hkey , & nameW , 0 , type , data , count ) ;
RtlFreeUnicodeString ( & nameW ) ;
2000-07-25 17:10:52 +02:00
}
2000-10-01 03:44:50 +02:00
if ( dataW ) HeapFree ( GetProcessHeap ( ) , 0 , dataW ) ;
return RtlNtStatusToDosError ( status ) ;
2000-07-25 17:10:52 +02:00
}
/******************************************************************************
* RegSetValueW [ ADVAPI32 .171 ]
*/
DWORD WINAPI RegSetValueW ( HKEY hkey , LPCWSTR name , DWORD type , LPCWSTR data , DWORD count )
{
HKEY subkey = hkey ;
DWORD ret ;
TRACE ( " (0x%x,%s,%ld,%s,%ld) \n " , hkey , debugstr_w ( name ) , type , debugstr_w ( data ) , count ) ;
if ( type ! = REG_SZ ) return ERROR_INVALID_PARAMETER ;
if ( name & & name [ 0 ] ) /* need to create the subkey */
{
if ( ( ret = RegCreateKeyW ( hkey , name , & subkey ) ) ! = ERROR_SUCCESS ) return ret ;
}
ret = RegSetValueExW ( subkey , NULL , 0 , REG_SZ , ( LPBYTE ) data ,
2000-08-14 16:41:19 +02:00
( strlenW ( data ) + 1 ) * sizeof ( WCHAR ) ) ;
2000-07-25 17:10:52 +02:00
if ( subkey ! = hkey ) RegCloseKey ( subkey ) ;
return ret ;
}
/******************************************************************************
* RegSetValueA [ ADVAPI32 .168 ]
*/
DWORD WINAPI RegSetValueA ( HKEY hkey , LPCSTR name , DWORD type , LPCSTR data , DWORD count )
{
HKEY subkey = hkey ;
DWORD ret ;
TRACE ( " (0x%x,%s,%ld,%s,%ld) \n " , hkey , debugstr_a ( name ) , type , debugstr_a ( data ) , count ) ;
if ( type ! = REG_SZ ) return ERROR_INVALID_PARAMETER ;
if ( name & & name [ 0 ] ) /* need to create the subkey */
{
if ( ( ret = RegCreateKeyA ( hkey , name , & subkey ) ) ! = ERROR_SUCCESS ) return ret ;
}
ret = RegSetValueExA ( subkey , NULL , 0 , REG_SZ , ( LPBYTE ) data , strlen ( data ) + 1 ) ;
if ( subkey ! = hkey ) RegCloseKey ( subkey ) ;
return ret ;
}
/******************************************************************************
* RegQueryValueExW [ ADVAPI32 .158 ]
*
* Retrieves type and data for a specified name associated with an open key
*
* PARAMS
* hkey [ I ] Handle of key to query
* name [ I ] Name of value to query
* reserved [ I ] Reserved - must be NULL
* type [ O ] Address of buffer for value type . If NULL , the type
* is not required .
* data [ O ] Address of data buffer . If NULL , the actual data is
* not required .
* count [ I / O ] Address of data buffer size
*
* RETURNS
* ERROR_SUCCESS : Success
* ERROR_MORE_DATA : ! ! ! if the specified buffer is not big enough to hold the data
* buffer is left untouched . The MS - documentation is wrong ( js ) ! ! !
*/
DWORD WINAPI RegQueryValueExW ( HKEY hkey , LPCWSTR name , LPDWORD reserved , LPDWORD type ,
2000-10-01 03:44:50 +02:00
LPBYTE data , LPDWORD count )
2000-07-25 17:10:52 +02:00
{
2000-10-01 03:44:50 +02:00
NTSTATUS status ;
UNICODE_STRING name_str ;
DWORD total_size ;
2000-10-02 05:46:58 +02:00
char buffer [ 256 ] , * buf_ptr = buffer ;
2000-10-01 03:44:50 +02:00
KEY_VALUE_PARTIAL_INFORMATION * info = ( KEY_VALUE_PARTIAL_INFORMATION * ) buffer ;
static const int info_size = sizeof ( * info ) - sizeof ( info - > Data ) ;
2000-07-25 17:10:52 +02:00
TRACE ( " (0x%x,%s,%p,%p,%p,%p=%ld) \n " ,
hkey , debugstr_w ( name ) , reserved , type , data , count , count ? * count : 0 ) ;
if ( ( data & & ! count ) | | reserved ) return ERROR_INVALID_PARAMETER ;
2000-10-01 03:44:50 +02:00
RtlInitUnicodeString ( & name_str , name ) ;
if ( data ) total_size = min ( sizeof ( buffer ) , * count + info_size ) ;
else total_size = info_size ;
status = NtQueryValueKey ( hkey , & name_str , KeyValuePartialInformation ,
buffer , total_size , & total_size ) ;
if ( status & & status ! = STATUS_BUFFER_OVERFLOW ) goto done ;
2000-07-25 17:10:52 +02:00
if ( data )
{
2000-10-01 03:44:50 +02:00
/* retry with a dynamically allocated buffer */
while ( status = = STATUS_BUFFER_OVERFLOW & & total_size - info_size < = * count )
2000-07-25 17:10:52 +02:00
{
2000-10-01 03:44:50 +02:00
if ( buf_ptr ! = buffer ) HeapFree ( GetProcessHeap ( ) , 0 , buf_ptr ) ;
if ( ! ( buf_ptr = HeapAlloc ( GetProcessHeap ( ) , 0 , total_size ) ) )
2000-10-02 05:46:58 +02:00
return ERROR_NOT_ENOUGH_MEMORY ;
info = ( KEY_VALUE_PARTIAL_INFORMATION * ) buf_ptr ;
status = NtQueryValueKey ( hkey , & name_str , KeyValuePartialInformation ,
buf_ptr , total_size , & total_size ) ;
2000-10-01 03:44:50 +02:00
}
if ( ! status )
{
memcpy ( data , buf_ptr + info_size , total_size - info_size ) ;
/* if the type is REG_SZ and data is not 0-terminated
* and there is enough space in the buffer NT appends a \ 0 */
if ( total_size - info_size < = * count - sizeof ( WCHAR ) & & is_string ( info - > Type ) )
2000-07-25 17:10:52 +02:00
{
2000-10-01 03:44:50 +02:00
WCHAR * ptr = ( WCHAR * ) ( data + total_size - info_size ) ;
if ( ptr > ( WCHAR * ) data & & ptr [ - 1 ] ) * ptr = 0 ;
2000-07-25 17:10:52 +02:00
}
}
2000-10-02 05:46:58 +02:00
else if ( status ! = STATUS_BUFFER_OVERFLOW ) goto done ;
2000-07-25 17:10:52 +02:00
}
2000-10-01 03:44:50 +02:00
if ( type ) * type = info - > Type ;
if ( count ) * count = total_size - info_size ;
done :
2000-10-02 05:46:58 +02:00
if ( buf_ptr ! = buffer ) HeapFree ( GetProcessHeap ( ) , 0 , buf_ptr ) ;
2000-10-01 03:44:50 +02:00
return RtlNtStatusToDosError ( status ) ;
2000-07-25 17:10:52 +02:00
}
/******************************************************************************
* RegQueryValueExA [ ADVAPI32 .157 ]
*
* NOTES :
2000-10-13 22:26:52 +02:00
* the documentation is wrong : if the buffer is too small it remains untouched
2000-07-25 17:10:52 +02:00
*/
DWORD WINAPI RegQueryValueExA ( HKEY hkey , LPCSTR name , LPDWORD reserved , LPDWORD type ,
2000-10-01 03:44:50 +02:00
LPBYTE data , LPDWORD count )
2000-07-25 17:10:52 +02:00
{
2000-10-01 03:44:50 +02:00
NTSTATUS status ;
ANSI_STRING nameA ;
UNICODE_STRING nameW ;
DWORD total_size ;
2000-10-02 05:46:58 +02:00
char buffer [ 256 ] , * buf_ptr = buffer ;
2000-10-01 03:44:50 +02:00
KEY_VALUE_PARTIAL_INFORMATION * info = ( KEY_VALUE_PARTIAL_INFORMATION * ) buffer ;
static const int info_size = sizeof ( * info ) - sizeof ( info - > Data ) ;
2000-07-25 17:10:52 +02:00
TRACE ( " (0x%x,%s,%p,%p,%p,%p=%ld) \n " ,
hkey , debugstr_a ( name ) , reserved , type , data , count , count ? * count : 0 ) ;
if ( ( data & & ! count ) | | reserved ) return ERROR_INVALID_PARAMETER ;
2000-10-01 03:44:50 +02:00
RtlInitAnsiString ( & nameA , name ) ;
/* FIXME: should use Unicode buffer in TEB */
2000-10-02 05:46:58 +02:00
if ( ( status = RtlAnsiStringToUnicodeString ( & nameW , & nameA , TRUE ) ) )
return RtlNtStatusToDosError ( status ) ;
2000-07-25 17:10:52 +02:00
2000-10-01 03:44:50 +02:00
status = NtQueryValueKey ( hkey , & nameW , KeyValuePartialInformation ,
buffer , sizeof ( buffer ) , & total_size ) ;
if ( status & & status ! = STATUS_BUFFER_OVERFLOW ) goto done ;
2000-07-25 17:10:52 +02:00
2000-10-01 03:44:50 +02:00
/* we need to fetch the contents for a string type even if not requested,
* because we need to compute the length of the ASCII string . */
if ( data | | is_string ( info - > Type ) )
2000-07-25 17:10:52 +02:00
{
2000-10-01 03:44:50 +02:00
/* retry with a dynamically allocated buffer */
while ( status = = STATUS_BUFFER_OVERFLOW )
2000-07-25 17:10:52 +02:00
{
2000-10-01 03:44:50 +02:00
if ( buf_ptr ! = buffer ) HeapFree ( GetProcessHeap ( ) , 0 , buf_ptr ) ;
if ( ! ( buf_ptr = HeapAlloc ( GetProcessHeap ( ) , 0 , total_size ) ) )
2000-10-02 05:46:58 +02:00
{
2000-10-01 03:44:50 +02:00
status = STATUS_NO_MEMORY ;
2000-10-02 05:46:58 +02:00
goto done ;
}
info = ( KEY_VALUE_PARTIAL_INFORMATION * ) buf_ptr ;
status = NtQueryValueKey ( hkey , & nameW , KeyValuePartialInformation ,
buf_ptr , total_size , & total_size ) ;
2000-10-01 03:44:50 +02:00
}
if ( ! status )
{
if ( is_string ( info - > Type ) )
2000-07-25 17:10:52 +02:00
{
2000-10-01 03:44:50 +02:00
DWORD len = WideCharToMultiByte ( CP_ACP , 0 , ( WCHAR * ) ( buf_ptr + info_size ) ,
( total_size - info_size ) / sizeof ( WCHAR ) ,
NULL , 0 , NULL , NULL ) ;
if ( data & & len )
{
if ( len > * count ) status = STATUS_BUFFER_OVERFLOW ;
else
{
WideCharToMultiByte ( CP_ACP , 0 , ( WCHAR * ) ( buf_ptr + info_size ) ,
( total_size - info_size ) / sizeof ( WCHAR ) ,
data , len , NULL , NULL ) ;
/* if the type is REG_SZ and data is not 0-terminated
* and there is enough space in the buffer NT appends a \ 0 */
if ( len < * count & & data [ len - 1 ] ) data [ len ] = 0 ;
}
}
total_size = len + info_size ;
}
2000-10-13 19:04:14 +02:00
else if ( data )
{
if ( total_size - info_size > * count ) status = STATUS_BUFFER_OVERFLOW ;
else memcpy ( data , buf_ptr + info_size , total_size - info_size ) ;
}
2000-07-25 17:10:52 +02:00
}
2000-10-02 05:46:58 +02:00
else if ( status ! = STATUS_BUFFER_OVERFLOW ) goto done ;
2000-07-25 17:10:52 +02:00
}
2000-10-01 03:44:50 +02:00
if ( type ) * type = info - > Type ;
if ( count ) * count = total_size - info_size ;
done :
2000-10-02 05:46:58 +02:00
if ( buf_ptr ! = buffer ) HeapFree ( GetProcessHeap ( ) , 0 , buf_ptr ) ;
RtlFreeUnicodeString ( & nameW ) ;
2000-10-01 03:44:50 +02:00
return RtlNtStatusToDosError ( status ) ;
2000-07-25 17:10:52 +02:00
}
/******************************************************************************
* RegQueryValueW [ ADVAPI32 .159 ]
*/
DWORD WINAPI RegQueryValueW ( HKEY hkey , LPCWSTR name , LPWSTR data , LPLONG count )
{
DWORD ret ;
HKEY subkey = hkey ;
TRACE ( " (%x,%s,%p,%ld) \n " , hkey , debugstr_w ( name ) , data , count ? * count : 0 ) ;
if ( name & & name [ 0 ] )
{
if ( ( ret = RegOpenKeyW ( hkey , name , & subkey ) ) ! = ERROR_SUCCESS ) return ret ;
}
ret = RegQueryValueExW ( subkey , NULL , NULL , NULL , ( LPBYTE ) data , count ) ;
if ( subkey ! = hkey ) RegCloseKey ( subkey ) ;
if ( ret = = ERROR_FILE_NOT_FOUND )
{
/* return empty string if default value not found */
if ( data ) * data = 0 ;
if ( count ) * count = 1 ;
ret = ERROR_SUCCESS ;
}
return ret ;
}
/******************************************************************************
* RegQueryValueA [ ADVAPI32 .156 ]
*/
DWORD WINAPI RegQueryValueA ( HKEY hkey , LPCSTR name , LPSTR data , LPLONG count )
{
DWORD ret ;
HKEY subkey = hkey ;
TRACE ( " (%x,%s,%p,%ld) \n " , hkey , debugstr_a ( name ) , data , count ? * count : 0 ) ;
if ( name & & name [ 0 ] )
{
if ( ( ret = RegOpenKeyA ( hkey , name , & subkey ) ) ! = ERROR_SUCCESS ) return ret ;
}
ret = RegQueryValueExA ( subkey , NULL , NULL , NULL , ( LPBYTE ) data , count ) ;
if ( subkey ! = hkey ) RegCloseKey ( subkey ) ;
if ( ret = = ERROR_FILE_NOT_FOUND )
{
/* return empty string if default value not found */
if ( data ) * data = 0 ;
if ( count ) * count = 1 ;
ret = ERROR_SUCCESS ;
}
return ret ;
}
/******************************************************************************
* RegEnumValueW [ ADVAPI32 .142 ]
*
* PARAMS
* hkey [ I ] Handle to key to query
* index [ I ] Index of value to query
* value [ O ] Value string
* val_count [ I / O ] Size of value buffer ( in wchars )
* reserved [ I ] Reserved
* type [ O ] Type code
* data [ O ] Value data
* count [ I / O ] Size of data buffer ( in bytes )
*/
DWORD WINAPI RegEnumValueW ( HKEY hkey , DWORD index , LPWSTR value , LPDWORD val_count ,
LPDWORD reserved , LPDWORD type , LPBYTE data , LPDWORD count )
{
DWORD ret , len ;
struct enum_key_value_request * req = get_req_buffer ( ) ;
TRACE ( " (%x,%ld,%p,%p,%p,%p,%p,%p) \n " ,
hkey , index , value , val_count , reserved , type , data , count ) ;
/* NT only checks count, not val_count */
if ( ( data & & ! count ) | | reserved ) return ERROR_INVALID_PARAMETER ;
req - > hkey = hkey ;
req - > index = index ;
req - > offset = 0 ;
if ( ( ret = reg_server_call ( REQ_ENUM_KEY_VALUE ) ) ! = ERROR_SUCCESS ) return ret ;
2000-08-14 16:41:19 +02:00
len = strlenW ( req - > name ) + 1 ;
2000-07-25 17:10:52 +02:00
if ( len > * val_count ) return ERROR_MORE_DATA ;
memcpy ( value , req - > name , len * sizeof ( WCHAR ) ) ;
* val_count = len - 1 ;
if ( data )
{
if ( * count < req - > len ) ret = ERROR_MORE_DATA ;
else
{
/* copy the data */
unsigned int max = server_remaining ( req - > data ) ;
unsigned int pos = 0 ;
while ( pos < req - > len )
{
unsigned int len = min ( req - > len - pos , max ) ;
memcpy ( data + pos , req - > data , len ) ;
if ( ( pos + = len ) > = req - > len ) break ;
req - > offset = pos ;
if ( ( ret = reg_server_call ( REQ_ENUM_KEY_VALUE ) ) ! = ERROR_SUCCESS ) return ret ;
}
}
/* if the type is REG_SZ and data is not 0-terminated
* and there is enough space in the buffer NT appends a \ 0 */
if ( req - > len & & is_string ( req - > type ) & &
( req - > len < * count ) & & ( ( WCHAR * ) data ) [ req - > len - 1 ] ) ( ( WCHAR * ) data ) [ req - > len ] = 0 ;
}
if ( type ) * type = req - > type ;
if ( count ) * count = req - > len ;
return ret ;
}
/******************************************************************************
* RegEnumValueA [ ADVAPI32 .141 ]
*/
DWORD WINAPI RegEnumValueA ( HKEY hkey , DWORD index , LPSTR value , LPDWORD val_count ,
LPDWORD reserved , LPDWORD type , LPBYTE data , LPDWORD count )
{
DWORD ret , len , total_len ;
struct enum_key_value_request * req = get_req_buffer ( ) ;
TRACE ( " (%x,%ld,%p,%p,%p,%p,%p,%p) \n " ,
hkey , index , value , val_count , reserved , type , data , count ) ;
/* NT only checks count, not val_count */
if ( ( data & & ! count ) | | reserved ) return ERROR_INVALID_PARAMETER ;
req - > hkey = hkey ;
req - > index = index ;
req - > offset = 0 ;
if ( ( ret = reg_server_call ( REQ_ENUM_KEY_VALUE ) ) ! = ERROR_SUCCESS ) return ret ;
2000-08-14 16:41:19 +02:00
len = strlenW ( req - > name ) + 1 ;
2000-07-25 17:10:52 +02:00
if ( len > * val_count ) return ERROR_MORE_DATA ;
memcpyWtoA ( value , req - > name , len ) ;
* val_count = len - 1 ;
total_len = is_string ( req - > type ) ? req - > len / sizeof ( WCHAR ) : req - > len ;
if ( data )
{
if ( * count < total_len ) ret = ERROR_MORE_DATA ;
else
{
/* copy the data */
unsigned int max = server_remaining ( req - > data ) ;
unsigned int pos = 0 ;
while ( pos < req - > len )
{
unsigned int len = min ( req - > len - pos , max ) ;
if ( is_string ( req - > type ) )
memcpyWtoA ( data + pos / sizeof ( WCHAR ) , ( WCHAR * ) req - > data , len / sizeof ( WCHAR ) ) ;
else
memcpy ( data + pos , req - > data , len ) ;
if ( ( pos + = len ) > = req - > len ) break ;
req - > offset = pos ;
if ( ( ret = reg_server_call ( REQ_ENUM_KEY_VALUE ) ) ! = ERROR_SUCCESS ) return ret ;
}
}
/* if the type is REG_SZ and data is not 0-terminated
* and there is enough space in the buffer NT appends a \ 0 */
if ( total_len & & is_string ( req - > type ) & & ( total_len < * count ) & & data [ total_len - 1 ] )
data [ total_len ] = 0 ;
}
if ( count ) * count = total_len ;
if ( type ) * type = req - > type ;
return ret ;
}
/******************************************************************************
* RegDeleteValueW [ ADVAPI32 .136 ]
*
* PARAMS
* hkey [ I ] handle to key
* name [ I ] name of value to delete
*
* RETURNS
* error status
*/
DWORD WINAPI RegDeleteValueW ( HKEY hkey , LPCWSTR name )
{
2000-10-01 03:44:50 +02:00
UNICODE_STRING nameW ;
RtlInitUnicodeString ( & nameW , name ) ;
return RtlNtStatusToDosError ( NtDeleteValueKey ( hkey , & nameW ) ) ;
2000-07-25 17:10:52 +02:00
}
/******************************************************************************
* RegDeleteValueA [ ADVAPI32 .135 ]
*/
DWORD WINAPI RegDeleteValueA ( HKEY hkey , LPCSTR name )
{
2000-10-01 03:44:50 +02:00
UNICODE_STRING nameW ;
STRING nameA ;
NTSTATUS status ;
2000-07-25 17:10:52 +02:00
2000-10-01 03:44:50 +02:00
RtlInitAnsiString ( & nameA , name ) ;
/* FIXME: should use Unicode buffer in TEB */
if ( ! ( status = RtlAnsiStringToUnicodeString ( & nameW , & nameA , TRUE ) ) )
{
status = NtDeleteValueKey ( hkey , & nameW ) ;
RtlFreeUnicodeString ( & nameW ) ;
}
return RtlNtStatusToDosError ( status ) ;
2000-07-25 17:10:52 +02:00
}
/******************************************************************************
* RegLoadKeyW [ ADVAPI32 .185 ]
*
* PARAMS
* hkey [ I ] Handle of open key
* subkey [ I ] Address of name of subkey
* filename [ I ] Address of filename for registry information
*/
LONG WINAPI RegLoadKeyW ( HKEY hkey , LPCWSTR subkey , LPCWSTR filename )
{
struct load_registry_request * req = get_req_buffer ( ) ;
HANDLE file ;
DWORD ret , err = GetLastError ( ) ;
TRACE ( " (%x,%s,%s) \n " , hkey , debugstr_w ( subkey ) , debugstr_w ( filename ) ) ;
if ( ! filename | | ! * filename ) return ERROR_INVALID_PARAMETER ;
if ( ! subkey | | ! * subkey ) return ERROR_INVALID_PARAMETER ;
if ( ( file = CreateFileW ( filename , GENERIC_READ , 0 , NULL , OPEN_EXISTING ,
FILE_ATTRIBUTE_NORMAL , - 1 ) ) = = INVALID_HANDLE_VALUE )
{
ret = GetLastError ( ) ;
goto done ;
}
req - > hkey = hkey ;
req - > file = file ;
if ( ( ret = copy_nameW ( req - > name , subkey ) ) ! = ERROR_SUCCESS ) goto done ;
ret = reg_server_call ( REQ_LOAD_REGISTRY ) ;
CloseHandle ( file ) ;
done :
SetLastError ( err ) ; /* restore the last error code */
return ret ;
}
/******************************************************************************
* RegLoadKeyA [ ADVAPI32 .184 ]
*/
LONG WINAPI RegLoadKeyA ( HKEY hkey , LPCSTR subkey , LPCSTR filename )
{
struct load_registry_request * req = get_req_buffer ( ) ;
HANDLE file ;
DWORD ret , err = GetLastError ( ) ;
TRACE ( " (%x,%s,%s) \n " , hkey , debugstr_a ( subkey ) , debugstr_a ( filename ) ) ;
if ( ! filename | | ! * filename ) return ERROR_INVALID_PARAMETER ;
if ( ! subkey | | ! * subkey ) return ERROR_INVALID_PARAMETER ;
if ( ( file = CreateFileA ( filename , GENERIC_READ , 0 , NULL , OPEN_EXISTING ,
FILE_ATTRIBUTE_NORMAL , - 1 ) ) = = INVALID_HANDLE_VALUE )
{
ret = GetLastError ( ) ;
goto done ;
}
req - > hkey = hkey ;
req - > file = file ;
if ( ( ret = copy_nameAtoW ( req - > name , subkey ) ) ! = ERROR_SUCCESS ) goto done ;
ret = reg_server_call ( REQ_LOAD_REGISTRY ) ;
CloseHandle ( file ) ;
done :
SetLastError ( err ) ; /* restore the last error code */
return ret ;
}
/******************************************************************************
* RegSaveKeyA [ ADVAPI32 .165 ]
*
* PARAMS
* hkey [ I ] Handle of key where save begins
* lpFile [ I ] Address of filename to save to
* sa [ I ] Address of security structure
*/
LONG WINAPI RegSaveKeyA ( HKEY hkey , LPCSTR file , LPSECURITY_ATTRIBUTES sa )
{
struct save_registry_request * req = get_req_buffer ( ) ;
char buffer [ 1024 ] ;
int count = 0 ;
LPSTR name ;
DWORD ret , err ;
HFILE handle ;
TRACE ( " (%x,%s,%p) \n " , hkey , debugstr_a ( file ) , sa ) ;
if ( ! file | | ! * file ) return ERROR_INVALID_PARAMETER ;
err = GetLastError ( ) ;
GetFullPathNameA ( file , sizeof ( buffer ) , buffer , & name ) ;
for ( ; ; )
{
sprintf ( name , " reg%04x.tmp " , count + + ) ;
handle = CreateFileA ( buffer , GENERIC_WRITE , 0 , NULL ,
CREATE_NEW , FILE_ATTRIBUTE_NORMAL , - 1 ) ;
if ( handle ! = INVALID_HANDLE_VALUE ) break ;
if ( ( ret = GetLastError ( ) ) ! = ERROR_ALREADY_EXISTS ) goto done ;
/* Something gone haywire ? Please report if this happens abnormally */
if ( count > = 100 )
MESSAGE ( " Wow, we are already fiddling with a temp file %s with an ordinal as high as %d ! \n You might want to delete all corresponding temp files in that directory. \n " , buffer , count ) ;
}
req - > hkey = hkey ;
req - > file = handle ;
ret = reg_server_call ( REQ_SAVE_REGISTRY ) ;
CloseHandle ( handle ) ;
if ( ! ret )
{
if ( ! MoveFileExA ( buffer , file , MOVEFILE_REPLACE_EXISTING ) )
{
ERR ( " Failed to move %s to %s \n " , buffer , file ) ;
ret = GetLastError ( ) ;
}
}
if ( ret ) DeleteFileA ( buffer ) ;
done :
SetLastError ( err ) ; /* restore last error code */
return ret ;
}
/******************************************************************************
* RegSaveKeyW [ ADVAPI32 .166 ]
*/
LONG WINAPI RegSaveKeyW ( HKEY hkey , LPCWSTR file , LPSECURITY_ATTRIBUTES sa )
{
LPSTR fileA = HEAP_strdupWtoA ( GetProcessHeap ( ) , 0 , file ) ;
DWORD ret = RegSaveKeyA ( hkey , fileA , sa ) ;
if ( fileA ) HeapFree ( GetProcessHeap ( ) , 0 , fileA ) ;
return ret ;
}