824 lines
28 KiB
C
824 lines
28 KiB
C
/*
|
|
* Registry functions
|
|
*
|
|
* Copyright 1999 Juergen Schmied
|
|
* Copyright 2000 Alexandre Julliard
|
|
* Copyright 2005 Ivan Leo Puoti, Laurent Pinchart
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*
|
|
*/
|
|
|
|
#if 0
|
|
#pragma makedep unix
|
|
#endif
|
|
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
|
|
#include "ntstatus.h"
|
|
#define WIN32_NO_STATUS
|
|
#include "winternl.h"
|
|
#include "unix_private.h"
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(reg);
|
|
|
|
/* maximum length of a value name in bytes (without terminating null) */
|
|
#define MAX_VALUE_LENGTH (16383 * sizeof(WCHAR))
|
|
|
|
|
|
NTSTATUS open_hkcu_key( const char *path, HANDLE *key )
|
|
{
|
|
NTSTATUS status;
|
|
char buffer[256];
|
|
WCHAR bufferW[256];
|
|
DWORD_PTR sid_data[(sizeof(TOKEN_USER) + SECURITY_MAX_SID_SIZE) / sizeof(DWORD_PTR)];
|
|
DWORD i, len = sizeof(sid_data);
|
|
SID *sid;
|
|
UNICODE_STRING name;
|
|
OBJECT_ATTRIBUTES attr;
|
|
|
|
status = NtQueryInformationToken( GetCurrentThreadEffectiveToken(), TokenUser, sid_data, len, &len );
|
|
if (status) return status;
|
|
|
|
sid = ((TOKEN_USER *)sid_data)->User.Sid;
|
|
len = sprintf( buffer, "\\Registry\\User\\S-%u-%u", sid->Revision,
|
|
MAKELONG( MAKEWORD( sid->IdentifierAuthority.Value[5], sid->IdentifierAuthority.Value[4] ),
|
|
MAKEWORD( sid->IdentifierAuthority.Value[3], sid->IdentifierAuthority.Value[2] )));
|
|
for (i = 0; i < sid->SubAuthorityCount; i++)
|
|
len += sprintf( buffer + len, "-%u", sid->SubAuthority[i] );
|
|
len += sprintf( buffer + len, "\\%s", path );
|
|
|
|
ascii_to_unicode( bufferW, buffer, len + 1 );
|
|
init_unicode_string( &name, bufferW );
|
|
InitializeObjectAttributes( &attr, &name, OBJ_CASE_INSENSITIVE, 0, NULL );
|
|
return NtCreateKey( key, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL );
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtCreateKey (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtCreateKey( HANDLE *key, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
|
|
ULONG index, const UNICODE_STRING *class, ULONG options, ULONG *dispos )
|
|
{
|
|
NTSTATUS ret;
|
|
data_size_t len;
|
|
struct object_attributes *objattr;
|
|
|
|
if (!key || !attr) return STATUS_ACCESS_VIOLATION;
|
|
if (attr->Length > sizeof(OBJECT_ATTRIBUTES)) return STATUS_INVALID_PARAMETER;
|
|
|
|
TRACE( "(%p,%s,%s,%x,%x,%p)\n", attr->RootDirectory, debugstr_us(attr->ObjectName),
|
|
debugstr_us(class), options, access, key );
|
|
|
|
if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
|
|
|
|
SERVER_START_REQ( create_key )
|
|
{
|
|
req->access = access;
|
|
req->options = options;
|
|
wine_server_add_data( req, objattr, len );
|
|
if (class) wine_server_add_data( req, class->Buffer, class->Length );
|
|
ret = wine_server_call( req );
|
|
*key = wine_server_ptr_handle( reply->hkey );
|
|
if (dispos && !ret) *dispos = reply->created ? REG_CREATED_NEW_KEY : REG_OPENED_EXISTING_KEY;
|
|
}
|
|
SERVER_END_REQ;
|
|
|
|
TRACE( "<- %p\n", *key );
|
|
free( objattr );
|
|
return ret;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtCreateKeyTransacted (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtCreateKeyTransacted( HANDLE *key, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
|
|
ULONG index, const UNICODE_STRING *class, ULONG options,
|
|
HANDLE transacted, ULONG *dispos )
|
|
{
|
|
FIXME( "(%p,%s,%s,%x,%x,%p,%p)\n", attr->RootDirectory, debugstr_us(attr->ObjectName),
|
|
debugstr_us(class), options, access, transacted, key );
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtOpenKeyEx (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtOpenKeyEx( HANDLE *key, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr, ULONG options )
|
|
{
|
|
NTSTATUS ret;
|
|
|
|
if (!key || !attr || !attr->ObjectName) return STATUS_ACCESS_VIOLATION;
|
|
if (attr->Length != sizeof(*attr)) return STATUS_INVALID_PARAMETER;
|
|
if (attr->ObjectName->Length & 1) return STATUS_OBJECT_NAME_INVALID;
|
|
|
|
TRACE( "(%p,%s,%x,%p)\n", attr->RootDirectory, debugstr_us(attr->ObjectName), access, key );
|
|
|
|
if (options & ~REG_OPTION_OPEN_LINK) FIXME( "options %x not implemented\n", options );
|
|
|
|
SERVER_START_REQ( open_key )
|
|
{
|
|
req->parent = wine_server_obj_handle( attr->RootDirectory );
|
|
req->access = access;
|
|
req->attributes = attr->Attributes;
|
|
wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
|
|
ret = wine_server_call( req );
|
|
*key = wine_server_ptr_handle( reply->hkey );
|
|
}
|
|
SERVER_END_REQ;
|
|
TRACE("<- %p\n", *key);
|
|
return ret;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtOpenKey (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtOpenKey( HANDLE *key, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
|
|
{
|
|
return NtOpenKeyEx( key, access, attr, 0 );
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtOpenKeyTransactedEx (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtOpenKeyTransactedEx( HANDLE *key, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
|
|
ULONG options, HANDLE transaction )
|
|
{
|
|
FIXME( "(%p %x %p %x %p)\n", key, access, attr, options, transaction );
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtOpenKeyTransacted (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtOpenKeyTransacted( HANDLE *key, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
|
|
HANDLE transaction )
|
|
{
|
|
return NtOpenKeyTransactedEx( key, access, attr, 0, transaction );
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtDeleteKey (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtDeleteKey( HANDLE key )
|
|
{
|
|
NTSTATUS ret;
|
|
|
|
TRACE( "(%p)\n", key );
|
|
|
|
SERVER_START_REQ( delete_key )
|
|
{
|
|
req->hkey = wine_server_obj_handle( key );
|
|
ret = wine_server_call( req );
|
|
}
|
|
SERVER_END_REQ;
|
|
return ret;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtRenameKey (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtRenameKey( HANDLE handle, UNICODE_STRING *name )
|
|
{
|
|
FIXME( "(%p %s)\n", handle, debugstr_us(name) );
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* enumerate_key
|
|
*
|
|
* Implementation of NtQueryKey and NtEnumerateKey
|
|
*/
|
|
static NTSTATUS enumerate_key( HANDLE handle, int index, KEY_INFORMATION_CLASS info_class,
|
|
void *info, DWORD length, DWORD *result_len )
|
|
|
|
{
|
|
NTSTATUS ret;
|
|
void *data_ptr;
|
|
size_t fixed_size;
|
|
|
|
switch (info_class)
|
|
{
|
|
case KeyBasicInformation: data_ptr = ((KEY_BASIC_INFORMATION *)info)->Name; break;
|
|
case KeyFullInformation: data_ptr = ((KEY_FULL_INFORMATION *)info)->Class; break;
|
|
case KeyNodeInformation: data_ptr = ((KEY_NODE_INFORMATION *)info)->Name; break;
|
|
case KeyNameInformation: data_ptr = ((KEY_NAME_INFORMATION *)info)->Name; break;
|
|
case KeyCachedInformation: data_ptr = ((KEY_CACHED_INFORMATION *)info)+1; break;
|
|
default:
|
|
FIXME( "Information class %d not implemented\n", info_class );
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
fixed_size = (char *)data_ptr - (char *)info;
|
|
|
|
SERVER_START_REQ( enum_key )
|
|
{
|
|
req->hkey = wine_server_obj_handle( handle );
|
|
req->index = index;
|
|
req->info_class = info_class;
|
|
if (length > fixed_size) wine_server_set_reply( req, data_ptr, length - fixed_size );
|
|
if (!(ret = wine_server_call( req )))
|
|
{
|
|
switch (info_class)
|
|
{
|
|
case KeyBasicInformation:
|
|
{
|
|
KEY_BASIC_INFORMATION keyinfo;
|
|
fixed_size = (char *)keyinfo.Name - (char *)&keyinfo;
|
|
keyinfo.LastWriteTime.QuadPart = reply->modif;
|
|
keyinfo.TitleIndex = 0;
|
|
keyinfo.NameLength = reply->namelen;
|
|
memcpy( info, &keyinfo, min( length, fixed_size ) );
|
|
break;
|
|
}
|
|
|
|
case KeyFullInformation:
|
|
{
|
|
KEY_FULL_INFORMATION keyinfo;
|
|
fixed_size = (char *)keyinfo.Class - (char *)&keyinfo;
|
|
keyinfo.LastWriteTime.QuadPart = reply->modif;
|
|
keyinfo.TitleIndex = 0;
|
|
keyinfo.ClassLength = wine_server_reply_size(reply);
|
|
keyinfo.ClassOffset = keyinfo.ClassLength ? fixed_size : -1;
|
|
keyinfo.SubKeys = reply->subkeys;
|
|
keyinfo.MaxNameLen = reply->max_subkey;
|
|
keyinfo.MaxClassLen = reply->max_class;
|
|
keyinfo.Values = reply->values;
|
|
keyinfo.MaxValueNameLen = reply->max_value;
|
|
keyinfo.MaxValueDataLen = reply->max_data;
|
|
memcpy( info, &keyinfo, min( length, fixed_size ) );
|
|
break;
|
|
}
|
|
|
|
case KeyNodeInformation:
|
|
{
|
|
KEY_NODE_INFORMATION keyinfo;
|
|
fixed_size = (char *)keyinfo.Name - (char *)&keyinfo;
|
|
keyinfo.LastWriteTime.QuadPart = reply->modif;
|
|
keyinfo.TitleIndex = 0;
|
|
if (reply->namelen < wine_server_reply_size(reply))
|
|
{
|
|
keyinfo.ClassLength = wine_server_reply_size(reply) - reply->namelen;
|
|
keyinfo.ClassOffset = fixed_size + reply->namelen;
|
|
}
|
|
else
|
|
{
|
|
keyinfo.ClassLength = 0;
|
|
keyinfo.ClassOffset = -1;
|
|
}
|
|
keyinfo.NameLength = reply->namelen;
|
|
memcpy( info, &keyinfo, min( length, fixed_size ) );
|
|
break;
|
|
}
|
|
|
|
case KeyNameInformation:
|
|
{
|
|
KEY_NAME_INFORMATION keyinfo;
|
|
fixed_size = (char *)keyinfo.Name - (char *)&keyinfo;
|
|
keyinfo.NameLength = reply->namelen;
|
|
memcpy( info, &keyinfo, min( length, fixed_size ) );
|
|
break;
|
|
}
|
|
|
|
case KeyCachedInformation:
|
|
{
|
|
KEY_CACHED_INFORMATION keyinfo;
|
|
fixed_size = sizeof(keyinfo);
|
|
keyinfo.LastWriteTime.QuadPart = reply->modif;
|
|
keyinfo.TitleIndex = 0;
|
|
keyinfo.SubKeys = reply->subkeys;
|
|
keyinfo.MaxNameLen = reply->max_subkey;
|
|
keyinfo.Values = reply->values;
|
|
keyinfo.MaxValueNameLen = reply->max_value;
|
|
keyinfo.MaxValueDataLen = reply->max_data;
|
|
keyinfo.NameLength = reply->namelen;
|
|
memcpy( info, &keyinfo, min( length, fixed_size ) );
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
*result_len = fixed_size + reply->total;
|
|
if (length < *result_len) ret = STATUS_BUFFER_OVERFLOW;
|
|
}
|
|
}
|
|
SERVER_END_REQ;
|
|
return ret;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtEnumerateKey (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtEnumerateKey( HANDLE handle, ULONG index, KEY_INFORMATION_CLASS info_class,
|
|
void *info, DWORD length, DWORD *result_len )
|
|
{
|
|
/* -1 means query key, so avoid it here */
|
|
if (index == (ULONG)-1) return STATUS_NO_MORE_ENTRIES;
|
|
return enumerate_key( handle, index, info_class, info, length, result_len );
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtQueryKey (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtQueryKey( HANDLE handle, KEY_INFORMATION_CLASS info_class,
|
|
void *info, DWORD length, DWORD *result_len )
|
|
{
|
|
return enumerate_key( handle, -1, info_class, info, length, result_len );
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtSetInformationKey (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtSetInformationKey( HANDLE key, int class, void *info, ULONG length )
|
|
{
|
|
FIXME( "(%p,0x%08x,%p,0x%08x) stub\n", key, class, info, length );
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
/* fill the key value info structure for a specific info class */
|
|
static void copy_key_value_info( KEY_VALUE_INFORMATION_CLASS info_class, void *info,
|
|
DWORD length, int type, int name_len, int data_len )
|
|
{
|
|
switch (info_class)
|
|
{
|
|
case KeyValueBasicInformation:
|
|
{
|
|
KEY_VALUE_BASIC_INFORMATION keyinfo;
|
|
keyinfo.TitleIndex = 0;
|
|
keyinfo.Type = type;
|
|
keyinfo.NameLength = name_len;
|
|
length = min( length, (char *)keyinfo.Name - (char *)&keyinfo );
|
|
memcpy( info, &keyinfo, length );
|
|
break;
|
|
}
|
|
|
|
case KeyValueFullInformation:
|
|
{
|
|
KEY_VALUE_FULL_INFORMATION keyinfo;
|
|
keyinfo.TitleIndex = 0;
|
|
keyinfo.Type = type;
|
|
keyinfo.DataOffset = (char *)keyinfo.Name - (char *)&keyinfo + name_len;
|
|
keyinfo.DataLength = data_len;
|
|
keyinfo.NameLength = name_len;
|
|
length = min( length, (char *)keyinfo.Name - (char *)&keyinfo );
|
|
memcpy( info, &keyinfo, length );
|
|
break;
|
|
}
|
|
|
|
case KeyValuePartialInformation:
|
|
{
|
|
KEY_VALUE_PARTIAL_INFORMATION keyinfo;
|
|
keyinfo.TitleIndex = 0;
|
|
keyinfo.Type = type;
|
|
keyinfo.DataLength = data_len;
|
|
length = min( length, (char *)keyinfo.Data - (char *)&keyinfo );
|
|
memcpy( info, &keyinfo, length );
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtEnumerateValueKey (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtEnumerateValueKey( HANDLE handle, ULONG index, KEY_VALUE_INFORMATION_CLASS info_class,
|
|
void *info, DWORD length, DWORD *result_len )
|
|
{
|
|
NTSTATUS ret;
|
|
void *ptr;
|
|
size_t fixed_size;
|
|
|
|
TRACE( "(%p,%u,%d,%p,%d)\n", handle, index, info_class, info, length );
|
|
|
|
/* compute the length we want to retrieve */
|
|
switch (info_class)
|
|
{
|
|
case KeyValueBasicInformation: ptr = ((KEY_VALUE_BASIC_INFORMATION *)info)->Name; break;
|
|
case KeyValueFullInformation: ptr = ((KEY_VALUE_FULL_INFORMATION *)info)->Name; break;
|
|
case KeyValuePartialInformation: ptr = ((KEY_VALUE_PARTIAL_INFORMATION *)info)->Data; break;
|
|
default:
|
|
FIXME( "Information class %d not implemented\n", info_class );
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
fixed_size = (char *)ptr - (char *)info;
|
|
|
|
SERVER_START_REQ( enum_key_value )
|
|
{
|
|
req->hkey = wine_server_obj_handle( handle );
|
|
req->index = index;
|
|
req->info_class = info_class;
|
|
if (length > fixed_size) wine_server_set_reply( req, ptr, length - fixed_size );
|
|
if (!(ret = wine_server_call( req )))
|
|
{
|
|
copy_key_value_info( info_class, info, length, reply->type, reply->namelen,
|
|
wine_server_reply_size(reply) - reply->namelen );
|
|
*result_len = fixed_size + reply->total;
|
|
if (length < *result_len) ret = STATUS_BUFFER_OVERFLOW;
|
|
}
|
|
}
|
|
SERVER_END_REQ;
|
|
return ret;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtQueryValueKey (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtQueryValueKey( HANDLE handle, const UNICODE_STRING *name,
|
|
KEY_VALUE_INFORMATION_CLASS info_class,
|
|
void *info, DWORD length, DWORD *result_len )
|
|
{
|
|
NTSTATUS ret;
|
|
UCHAR *data_ptr;
|
|
unsigned int fixed_size, min_size;
|
|
|
|
TRACE( "(%p,%s,%d,%p,%d)\n", handle, debugstr_us(name), info_class, info, length );
|
|
|
|
if (name->Length > MAX_VALUE_LENGTH) return STATUS_OBJECT_NAME_NOT_FOUND;
|
|
|
|
/* compute the length we want to retrieve */
|
|
switch(info_class)
|
|
{
|
|
case KeyValueBasicInformation:
|
|
{
|
|
KEY_VALUE_BASIC_INFORMATION *basic_info = info;
|
|
min_size = FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION, Name);
|
|
fixed_size = min_size + name->Length;
|
|
if (min_size < length)
|
|
memcpy(basic_info->Name, name->Buffer, min(length - min_size, name->Length));
|
|
data_ptr = NULL;
|
|
break;
|
|
}
|
|
|
|
case KeyValueFullInformation:
|
|
{
|
|
KEY_VALUE_FULL_INFORMATION *full_info = info;
|
|
min_size = FIELD_OFFSET(KEY_VALUE_FULL_INFORMATION, Name);
|
|
fixed_size = min_size + name->Length;
|
|
if (min_size < length)
|
|
memcpy(full_info->Name, name->Buffer, min(length - min_size, name->Length));
|
|
data_ptr = (UCHAR *)full_info->Name + name->Length;
|
|
break;
|
|
}
|
|
|
|
case KeyValuePartialInformation:
|
|
min_size = fixed_size = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data);
|
|
data_ptr = ((KEY_VALUE_PARTIAL_INFORMATION *)info)->Data;
|
|
break;
|
|
|
|
default:
|
|
FIXME( "Information class %d not implemented\n", info_class );
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
SERVER_START_REQ( get_key_value )
|
|
{
|
|
req->hkey = wine_server_obj_handle( handle );
|
|
wine_server_add_data( req, name->Buffer, name->Length );
|
|
if (length > fixed_size && data_ptr) wine_server_set_reply( req, data_ptr, length - fixed_size );
|
|
if (!(ret = wine_server_call( req )))
|
|
{
|
|
copy_key_value_info( info_class, info, length, reply->type,
|
|
name->Length, reply->total );
|
|
*result_len = fixed_size + (info_class == KeyValueBasicInformation ? 0 : reply->total);
|
|
if (length < min_size) ret = STATUS_BUFFER_TOO_SMALL;
|
|
else if (length < *result_len) ret = STATUS_BUFFER_OVERFLOW;
|
|
}
|
|
}
|
|
SERVER_END_REQ;
|
|
return ret;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtQueryMultipleValueKey (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtQueryMultipleValueKey( HANDLE key, KEY_MULTIPLE_VALUE_INFORMATION *info,
|
|
ULONG count, void *buffer, ULONG length, ULONG *retlen )
|
|
{
|
|
FIXME( "(%p,%p,0x%08x,%p,0x%08x,%p) stub!\n", key, info, count, buffer, length, retlen );
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtSetValueKey (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtSetValueKey( HANDLE key, const UNICODE_STRING *name, ULONG index,
|
|
ULONG type, const void *data, ULONG count )
|
|
{
|
|
NTSTATUS ret;
|
|
|
|
TRACE( "(%p,%s,%d,%p,%d)\n", key, debugstr_us(name), type, data, count );
|
|
|
|
if (name->Length > MAX_VALUE_LENGTH) return STATUS_INVALID_PARAMETER;
|
|
|
|
SERVER_START_REQ( set_key_value )
|
|
{
|
|
req->hkey = wine_server_obj_handle( key );
|
|
req->type = type;
|
|
req->namelen = name->Length;
|
|
wine_server_add_data( req, name->Buffer, name->Length );
|
|
wine_server_add_data( req, data, count );
|
|
ret = wine_server_call( req );
|
|
}
|
|
SERVER_END_REQ;
|
|
return ret;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtDeleteValueKey (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtDeleteValueKey( HANDLE key, const UNICODE_STRING *name )
|
|
{
|
|
NTSTATUS ret;
|
|
|
|
TRACE( "(%p,%s)\n", key, debugstr_us(name) );
|
|
|
|
if (name->Length > MAX_VALUE_LENGTH) return STATUS_OBJECT_NAME_NOT_FOUND;
|
|
|
|
SERVER_START_REQ( delete_key_value )
|
|
{
|
|
req->hkey = wine_server_obj_handle( key );
|
|
wine_server_add_data( req, name->Buffer, name->Length );
|
|
ret = wine_server_call( req );
|
|
}
|
|
SERVER_END_REQ;
|
|
return ret;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtNotifyChangeMultipleKeys (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtNotifyChangeMultipleKeys( HANDLE key, ULONG count, OBJECT_ATTRIBUTES *attr,
|
|
HANDLE event, PIO_APC_ROUTINE apc, void *apc_context,
|
|
IO_STATUS_BLOCK *io, ULONG filter, BOOLEAN subtree,
|
|
void *buffer, ULONG length, BOOLEAN async )
|
|
{
|
|
NTSTATUS ret;
|
|
|
|
TRACE( "(%p,%u,%p,%p,%p,%p,%p,0x%08x, 0x%08x,%p,0x%08x,0x%08x)\n",
|
|
key, count, attr, event, apc, apc_context, io, filter, async, buffer, length, subtree );
|
|
|
|
if (count || attr || apc || apc_context || buffer || length)
|
|
FIXME( "Unimplemented optional parameter\n" );
|
|
|
|
if (!async)
|
|
{
|
|
OBJECT_ATTRIBUTES attr;
|
|
InitializeObjectAttributes( &attr, NULL, 0, NULL, NULL );
|
|
ret = NtCreateEvent( &event, EVENT_ALL_ACCESS, &attr, SynchronizationEvent, FALSE );
|
|
if (ret) return ret;
|
|
}
|
|
|
|
SERVER_START_REQ( set_registry_notification )
|
|
{
|
|
req->hkey = wine_server_obj_handle( key );
|
|
req->event = wine_server_obj_handle( event );
|
|
req->subtree = subtree;
|
|
req->filter = filter;
|
|
ret = wine_server_call( req );
|
|
}
|
|
SERVER_END_REQ;
|
|
|
|
if (!async)
|
|
{
|
|
if (ret == STATUS_PENDING) ret = NtWaitForSingleObject( event, FALSE, NULL );
|
|
NtClose( event );
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtNotifyChangeKey (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtNotifyChangeKey( HANDLE key, HANDLE event, PIO_APC_ROUTINE apc, void *apc_context,
|
|
IO_STATUS_BLOCK *io, ULONG filter, BOOLEAN subtree,
|
|
void *buffer, ULONG length, BOOLEAN async )
|
|
{
|
|
return NtNotifyChangeMultipleKeys( key, 0, NULL, event, apc, apc_context,
|
|
io, filter, subtree, buffer, length, async );
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtFlushKey (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtFlushKey( HANDLE key )
|
|
{
|
|
NTSTATUS ret;
|
|
|
|
TRACE( "key=%p\n", key );
|
|
|
|
SERVER_START_REQ( flush_key )
|
|
{
|
|
req->hkey = wine_server_obj_handle( key );
|
|
ret = wine_server_call( req );
|
|
}
|
|
SERVER_END_REQ;
|
|
return ret;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtLoadKey (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtLoadKey( const OBJECT_ATTRIBUTES *attr, OBJECT_ATTRIBUTES *file )
|
|
{
|
|
NTSTATUS ret;
|
|
HANDLE key;
|
|
data_size_t len;
|
|
struct object_attributes *objattr;
|
|
char *unix_name;
|
|
UNICODE_STRING nt_name;
|
|
OBJECT_ATTRIBUTES new_attr = *file;
|
|
|
|
TRACE("(%p,%p)\n", attr, file);
|
|
|
|
get_redirect( &new_attr, &nt_name );
|
|
if (!(ret = nt_to_unix_file_name( &new_attr, &unix_name, FILE_OPEN )))
|
|
{
|
|
ret = open_unix_file( &key, unix_name, GENERIC_READ | SYNCHRONIZE,
|
|
&new_attr, 0, 0, FILE_OPEN, 0, NULL, 0 );
|
|
free( unix_name );
|
|
}
|
|
free( nt_name.Buffer );
|
|
|
|
if (ret) return ret;
|
|
|
|
if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
|
|
|
|
SERVER_START_REQ( load_registry )
|
|
{
|
|
req->file = wine_server_obj_handle( key );
|
|
wine_server_add_data( req, objattr, len );
|
|
ret = wine_server_call( req );
|
|
}
|
|
SERVER_END_REQ;
|
|
|
|
NtClose( key );
|
|
free( objattr );
|
|
return ret;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtLoadKey2 (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtLoadKey2( const OBJECT_ATTRIBUTES *attr, OBJECT_ATTRIBUTES *file, ULONG flags )
|
|
{
|
|
FIXME( "(%p,%p,0x%08x) semi-stub: ignoring flags\n", attr, file, flags );
|
|
return NtLoadKey( attr, file );
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtUnloadKey (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtUnloadKey( OBJECT_ATTRIBUTES *attr )
|
|
{
|
|
NTSTATUS ret;
|
|
|
|
TRACE( "(%p)\n", attr );
|
|
|
|
if (!attr || !attr->ObjectName) return STATUS_ACCESS_VIOLATION;
|
|
if (attr->Length != sizeof(*attr)) return STATUS_INVALID_PARAMETER;
|
|
if (attr->ObjectName->Length & 1) return STATUS_OBJECT_NAME_INVALID;
|
|
|
|
SERVER_START_REQ( unload_registry )
|
|
{
|
|
req->parent = wine_server_obj_handle( attr->RootDirectory );
|
|
req->attributes = attr->Attributes;
|
|
wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
|
|
ret = wine_server_call(req);
|
|
}
|
|
SERVER_END_REQ;
|
|
return ret;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtSaveKey (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtSaveKey( HANDLE key, HANDLE file )
|
|
{
|
|
NTSTATUS ret;
|
|
|
|
TRACE( "(%p,%p)\n", key, file );
|
|
|
|
SERVER_START_REQ( save_registry )
|
|
{
|
|
req->hkey = wine_server_obj_handle( key );
|
|
req->file = wine_server_obj_handle( file );
|
|
ret = wine_server_call( req );
|
|
}
|
|
SERVER_END_REQ;
|
|
return ret;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtRestoreKey (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtRestoreKey( HANDLE key, HANDLE file, ULONG flags )
|
|
{
|
|
FIXME( "(%p,%p,0x%08x) stub\n", key, file, flags );
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* NtReplaceKey (NTDLL.@)
|
|
*/
|
|
NTSTATUS WINAPI NtReplaceKey( OBJECT_ATTRIBUTES *attr, HANDLE key, OBJECT_ATTRIBUTES *replace )
|
|
{
|
|
FIXME( "(%s,%p,%s),stub!\n", debugstr_us(attr->ObjectName), key, debugstr_us(replace->ObjectName) );
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* NtQueryLicenseValue (NTDLL.@)
|
|
*
|
|
* NOTES
|
|
* On Windows all license properties are stored in a single key, but
|
|
* unless there is some app which explicitly depends on that, there is
|
|
* no good reason to reproduce that.
|
|
*/
|
|
NTSTATUS WINAPI NtQueryLicenseValue( const UNICODE_STRING *name, ULONG *type,
|
|
void *data, ULONG length, ULONG *retlen )
|
|
{
|
|
static const WCHAR nameW[] = {'M','a','c','h','i','n','e','\\',
|
|
'S','o','f','t','w','a','r','e','\\',
|
|
'W','i','n','e','\\','L','i','c','e','n','s','e',
|
|
'I','n','f','o','r','m','a','t','i','o','n',0};
|
|
UNICODE_STRING keyW = { sizeof(nameW) - sizeof(WCHAR), sizeof(nameW), (WCHAR *)nameW };
|
|
KEY_VALUE_PARTIAL_INFORMATION *info;
|
|
NTSTATUS status = STATUS_OBJECT_NAME_NOT_FOUND;
|
|
DWORD info_length, count;
|
|
OBJECT_ATTRIBUTES attr;
|
|
HANDLE key;
|
|
|
|
if (!name || !name->Buffer || !name->Length || !retlen) return STATUS_INVALID_PARAMETER;
|
|
|
|
info_length = FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION, Data ) + length;
|
|
if (!(info = malloc( info_length ))) return STATUS_NO_MEMORY;
|
|
|
|
InitializeObjectAttributes( &attr, &keyW, 0, 0, NULL );
|
|
|
|
/* @@ Wine registry key: HKLM\Software\Wine\LicenseInformation */
|
|
if (!NtOpenKey( &key, KEY_READ, &attr ))
|
|
{
|
|
status = NtQueryValueKey( key, name, KeyValuePartialInformation, info, info_length, &count );
|
|
if (!status || status == STATUS_BUFFER_OVERFLOW)
|
|
{
|
|
if (type) *type = info->Type;
|
|
*retlen = info->DataLength;
|
|
if (status == STATUS_BUFFER_OVERFLOW)
|
|
status = STATUS_BUFFER_TOO_SMALL;
|
|
else
|
|
memcpy( data, info->Data, info->DataLength );
|
|
}
|
|
NtClose( key );
|
|
}
|
|
|
|
if (status == STATUS_OBJECT_NAME_NOT_FOUND)
|
|
FIXME( "License key %s not found\n", debugstr_w(name->Buffer) );
|
|
|
|
free( info );
|
|
return status;
|
|
}
|