misc/registry.c - wine - Git at Google


            
            /*

            
             * 	Registry Functions

            
             *

            
             * Copyright 1996 Marcus Meissner

            
             * Copyright 1998 Matthew Becker

            
             * Copyright 1999 Sylvain St-Germain

            
             *

            
             * December 21, 1997 - Kevin Cozens

            
             * Fixed bugs in the _w95_loadreg() function. Added extra information

            
             * regarding the format of the Windows '95 registry files.

            
             *

            
             * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

            
             *

            
             * TODO

            
             *    Security access

            
             *    Option handling

            
             *    Time for RegEnumKey*, RegQueryInfoKey*

            
             */


            #include "config.h"

            
            #include "wine/port.h"


            #include <stdlib.h>

            
            #include <string.h>

            
            #include <stdarg.h>

            
            #include <stdio.h>

            
            #ifdef HAVE_UNISTD_H

            
            # include <unistd.h>

            
            #endif

            
            #include <errno.h>

            
            #include <sys/types.h>

            
            #include <sys/stat.h>

            
            #include <fcntl.h>

            
            #ifdef HAVE_SYS_IOCTL_H

            
            #include <sys/ioctl.h>

            
            #endif

            
            #ifdef HAVE_LINUX_HDREG_H

            
            # include <linux/hdreg.h>

            
            #endif


            #define NONAMELESSUNION

            
            #define NONAMELESSSTRUCT

            
            #include "ntstatus.h"

            
            #include "windef.h"

            
            #include "winbase.h"

            
            #include "winerror.h"

            
            #include "winioctl.h"

            
            #include "ntddscsi.h"


            #include "wine/library.h"

            
            #include "wine/server.h"

            
            #include "wine/unicode.h"


            #include "wine/debug.h"


            WINE_DEFAULT_DEBUG_CHANNEL(reg);


            /******************************************************************************

            
             * allocate_default_keys [Internal]

            
             * Registry initialisation, allocates some default keys.

            
             */

            
            static ULONG allocate_default_keys(void)

            
            {

            
                static const WCHAR StatDataW[] = {'D','y','n','D','a','t','a','\\',

            
                                                  'P','e','r','f','S','t','a','t','s','\\',

            
                                                  'S','t','a','t','D','a','t','a',0};

            
                static const WCHAR ConfigManagerW[] = {'D','y','n','D','a','t','a','\\',

            
                                                       'C','o','n','f','i','g',' ','M','a','n','a','g','e','r','\\',

            
                                                        'E','n','u','m',0};

            
                static const WCHAR Clone[] = {'M','a','c','h','i','n','e','\\',

            
                                              'S','y','s','t','e','m','\\',

            
                                              'C','l','o','n','e',0};

            
                HKEY hkey;

            
                ULONG dispos;

            
                OBJECT_ATTRIBUTES attr;

            
                UNICODE_STRING nameW;


                attr.Length = sizeof(attr);

            
                attr.RootDirectory = 0;

            
                attr.ObjectName = &nameW;

            
                attr.Attributes = 0;

            
                attr.SecurityDescriptor = NULL;

            
                attr.SecurityQualityOfService = NULL;


                RtlInitUnicodeString( &nameW, StatDataW );

            
                if (!NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, &dispos )) NtClose( hkey );

            
                if (dispos == REG_OPENED_EXISTING_KEY)

            
                    return dispos; /* someone else already loaded the registry */


                RtlInitUnicodeString( &nameW, ConfigManagerW );

            
                if (!NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL )) NtClose( hkey );


                /* this key is generated when the nt-core booted successfully */

            
                RtlInitUnicodeString( &nameW, Clone );

            
                if (!NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL )) NtClose( hkey );


                return dispos;

            
            }


            /******************************************************************

            
             *		init_cdrom_registry

            
             *

            
             * Initializes registry to contain scsi info about the cdrom in NT.

            
             * All devices (even not real scsi ones) have this info in NT.

            
             * TODO: for now it only works for non scsi devices

            
             * NOTE: programs usually read these registry entries after sending the

            
             *       IOCTL_SCSI_GET_ADDRESS ioctl to the cdrom

            
             */

            
            static void init_cdrom_registry( HANDLE handle )

            
            {

            
                OBJECT_ATTRIBUTES attr;

            
                UNICODE_STRING nameW;

            
                WCHAR dataW[50];

            
                DWORD lenW;

            
                char buffer[40];

            
                DWORD value;

            
                const char *data;

            
                HKEY scsiKey;

            
                HKEY portKey;

            
                HKEY busKey;

            
                HKEY targetKey;

            
                DWORD disp;

            
                IO_STATUS_BLOCK io;

            
                SCSI_ADDRESS scsi_addr;


                if (NtDeviceIoControlFile( handle, 0, NULL, NULL, &io, IOCTL_SCSI_GET_ADDRESS,

            
                                           NULL, 0, &scsi_addr, sizeof(scsi_addr) ))

            
                    return;


                attr.Length = sizeof(attr);

            
                attr.RootDirectory = 0;

            
                attr.ObjectName = &nameW;

            
                attr.Attributes = 0;

            
                attr.SecurityDescriptor = NULL;

            
                attr.SecurityQualityOfService = NULL;


                /* Ensure there is Scsi key */

            
                if (!RtlCreateUnicodeStringFromAsciiz( &nameW, "Machine\\HARDWARE\\DEVICEMAP\\Scsi" ) ||

            
                    NtCreateKey( &scsiKey, KEY_ALL_ACCESS, &attr, 0,

            
                                 NULL, REG_OPTION_VOLATILE, &disp ))

            
                {

            
                    ERR("Cannot create DEVICEMAP\\Scsi registry key\n" );

            
                    return;

            
                }

            
                RtlFreeUnicodeString( &nameW );


                snprintf(buffer,sizeof(buffer),"Scsi Port %d",scsi_addr.PortNumber);

            
                attr.RootDirectory = scsiKey;

            
                if (!RtlCreateUnicodeStringFromAsciiz( &nameW, buffer ) ||

            
                    NtCreateKey( &portKey, KEY_ALL_ACCESS, &attr, 0,

            
                                 NULL, REG_OPTION_VOLATILE, &disp ))

            
                {

            
                    ERR("Cannot create DEVICEMAP\\Scsi Port registry key\n" );

            
                    return;

            
                }

            
                RtlFreeUnicodeString( &nameW );


                RtlCreateUnicodeStringFromAsciiz( &nameW, "Driver" );

            
                data = "atapi";

            
                RtlMultiByteToUnicodeN( dataW, 50, &lenW, data, strlen(data));

            
                NtSetValueKey( portKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );

            
                RtlFreeUnicodeString( &nameW );

            
                value = 10;

            
                RtlCreateUnicodeStringFromAsciiz( &nameW, "FirstBusTimeScanInMs" );

            
                NtSetValueKey( portKey,&nameW, 0, REG_DWORD, (BYTE *)&value, sizeof(DWORD));

            
                RtlFreeUnicodeString( &nameW );

            
                value = 0;

            
            #ifdef HDIO_GET_DMA

            
                {

            
                    int fd, dma;

            
                    if (!wine_server_handle_to_fd( handle, 0, &fd, NULL ))

            
                    {

            
                        if (ioctl(fd,HDIO_GET_DMA, &dma) != -1) value = dma;

            
                        wine_server_release_fd( handle, fd );

            
                    }

            
                }

            
            #endif

            
                RtlCreateUnicodeStringFromAsciiz( &nameW, "DMAEnabled" );

            
                NtSetValueKey( portKey,&nameW, 0, REG_DWORD, (BYTE *)&value, sizeof(DWORD));

            
                RtlFreeUnicodeString( &nameW );


                snprintf(buffer,40,"Scsi Bus %d", scsi_addr.PathId);

            
                attr.RootDirectory = portKey;

            
                if (!RtlCreateUnicodeStringFromAsciiz( &nameW, buffer ) ||

            
                    NtCreateKey( &busKey, KEY_ALL_ACCESS, &attr, 0,

            
                                 NULL, REG_OPTION_VOLATILE, &disp ))

            
                {

            
                    ERR("Cannot create DEVICEMAP\\Scsi Port\\Scsi Bus registry key\n" );

            
                    return;

            
                }

            
                RtlFreeUnicodeString( &nameW );


                attr.RootDirectory = busKey;

            
                if (!RtlCreateUnicodeStringFromAsciiz( &nameW, "Initiator Id 255" ) ||

            
                    NtCreateKey( &targetKey, KEY_ALL_ACCESS, &attr, 0,

            
                                 NULL, REG_OPTION_VOLATILE, &disp ))

            
                {

            
                    ERR("Cannot create DEVICEMAP\\Scsi Port\\Scsi Bus\\Initiator Id 255 registry key\n" );

            
                    return;

            
                }

            
                RtlFreeUnicodeString( &nameW );

            
                NtClose( targetKey );


                snprintf(buffer,40,"Target Id %d", scsi_addr.TargetId);

            
                attr.RootDirectory = busKey;

            
                if (!RtlCreateUnicodeStringFromAsciiz( &nameW, buffer ) ||

            
                    NtCreateKey( &targetKey, KEY_ALL_ACCESS, &attr, 0,

            
                                 NULL, REG_OPTION_VOLATILE, &disp ))

            
                {

            
                    ERR("Cannot create DEVICEMAP\\Scsi Port\\Scsi Bus 0\\Target Id registry key\n" );

            
                    return;

            
                }

            
                RtlFreeUnicodeString( &nameW );


                RtlCreateUnicodeStringFromAsciiz( &nameW, "Type" );

            
                data = "CdRomPeripheral";

            
                RtlMultiByteToUnicodeN( dataW, 50, &lenW, data, strlen(data));

            
                NtSetValueKey( targetKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );

            
                RtlFreeUnicodeString( &nameW );

            
                /* FIXME - maybe read the real identifier?? */

            
                RtlCreateUnicodeStringFromAsciiz( &nameW, "Identifier" );

            
                data = "Wine CDROM";

            
                RtlMultiByteToUnicodeN( dataW, 50, &lenW, data, strlen(data));

            
                NtSetValueKey( targetKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );

            
                RtlFreeUnicodeString( &nameW );

            
                /* FIXME - we always use Cdrom0 - do not know about the nt behaviour */

            
                RtlCreateUnicodeStringFromAsciiz( &nameW, "DeviceName" );

            
                data = "Cdrom0";

            
                RtlMultiByteToUnicodeN( dataW, 50, &lenW, data, strlen(data));

            
                NtSetValueKey( targetKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );

            
                RtlFreeUnicodeString( &nameW );


                NtClose( targetKey );

            
                NtClose( busKey );

            
                NtClose( portKey );

            
                NtClose( scsiKey );

            
            }


            /* create the hardware registry branch */

            
            static void create_hardware_branch(void)

            
            {

            
                int i;

            
                HANDLE handle;

            
                char drive[] = "\\\\.\\A:";


                /* create entries for cdroms */

            
                for (i = 0; i < 26; i++)

            
                {

            
                    drive[4] = 'A' + i;

            
                    handle = CreateFileA( drive, 0, 0, NULL, OPEN_EXISTING, 0, 0 );

            
                    if (handle == INVALID_HANDLE_VALUE) continue;

            
                    init_cdrom_registry( handle );

            
                    CloseHandle( handle );

            
                }

            
            }


            /* convert the drive type entries from the old format to the new one */

            
            static void convert_drive_types(void)

            
            {

            
                static const WCHAR TypeW[] = {'T','y','p','e',0};

            
                static const WCHAR drive_types_keyW[] = {'M','a','c','h','i','n','e','\\',

            
                                                         'S','o','f','t','w','a','r','e','\\',

            
                                                         'W','i','n','e','\\',

            
                                                         'D','r','i','v','e','s',0 };

            
                WCHAR driveW[] = {'M','a','c','h','i','n','e','\\','S','o','f','t','w','a','r','e','\\',

            
                                  'W','i','n','e','\\','W','i','n','e','\\',

            
                                  'C','o','n','f','i','g','\\','D','r','i','v','e',' ','A',0};

            
                char tmp[32*sizeof(WCHAR) + sizeof(KEY_VALUE_PARTIAL_INFORMATION)];

            
                OBJECT_ATTRIBUTES attr;

            
                UNICODE_STRING nameW;

            
                DWORD dummy;

            
                ULONG disp;

            
                HKEY hkey_old, hkey_new;

            
                int i;


                attr.Length = sizeof(attr);

            
                attr.RootDirectory = 0;

            
                attr.ObjectName = &nameW;

            
                attr.Attributes = 0;

            
                attr.SecurityDescriptor = NULL;

            
                attr.SecurityQualityOfService = NULL;

            
                RtlInitUnicodeString( &nameW, drive_types_keyW );


                if (NtCreateKey( &hkey_new, KEY_ALL_ACCESS, &attr, 0, NULL, 0, &disp )) return;

            
                if (disp != REG_CREATED_NEW_KEY)

            
                {

            
                    NtClose( hkey_new );

            
                    return;

            
                }


                for (i = 0; i < 26; i++)

            
                {

            
                    RtlInitUnicodeString( &nameW, driveW );

            
                    nameW.Buffer[(nameW.Length / sizeof(WCHAR)) - 1] = 'A' + i;

            
                    if (NtOpenKey( &hkey_old, KEY_ALL_ACCESS, &attr ) != STATUS_SUCCESS) continue;

            
                    RtlInitUnicodeString( &nameW, TypeW );

            
                    if (!NtQueryValueKey( hkey_old, &nameW, KeyValuePartialInformation, tmp, sizeof(tmp), &dummy ))

            
                    {

            
                        WCHAR valueW[] = {'A',':',0};

            
                        WCHAR *type = (WCHAR *)((KEY_VALUE_PARTIAL_INFORMATION *)tmp)->Data;


                        valueW[0] = 'A' + i;

            
                        RtlInitUnicodeString( &nameW, valueW );

            
                        NtSetValueKey( hkey_new, &nameW, 0, REG_SZ, type, (strlenW(type) + 1) * sizeof(WCHAR) );

            
                        MESSAGE( "Converted drive type to new entry HKLM\\Software\\Wine\\Drives \"%c:\" = %s\n",

            
                                 'A' + i, debugstr_w(type) );

            
                    }

            
                    NtClose( hkey_old );

            
                }

            
                NtClose( hkey_new );

            
            }


            /* convert the environment variable entries from the old format to the new one */

            
            static void convert_environment( HKEY hkey_current_user )

            
            {

            
                static const WCHAR wineW[] = {'M','a','c','h','i','n','e','\\',

            
                                              'S','o','f','t','w','a','r','e','\\',

            
                                              'W','i','n','e','\\','W','i','n','e','\\',

            
                                              'C','o','n','f','i','g','\\','W','i','n','e',0};

            
                static const WCHAR windowsW[] = {'w','i','n','d','o','w','s',0};

            
                static const WCHAR systemW[] = {'s','y','s','t','e','m',0};

            
                static const WCHAR windirW[] = {'w','i','n','d','i','r',0};

            
                static const WCHAR systemrootW[] = {'S','y','s','t','e','m','r','o','o','t',0};

            
                static const WCHAR winsysdirW[] = {'w','i','n','s','y','s','d','i','r',0};

            
                static const WCHAR envW[] = {'E','n','v','i','r','o','n','m','e','n','t',0};

            
                static const WCHAR tempW[] = {'T','E','M','P',0};

            
                static const WCHAR tmpW[] = {'T','M','P',0};

            
                static const WCHAR pathW[] = {'P','A','T','H',0};

            
                static const WCHAR profileW[] = {'p','r','o','f','i','l','e',0};

            
                static const WCHAR userprofileW[] = {'U','S','E','R','P','R','O','F','I','L','E',0};


                char buffer[1024*sizeof(WCHAR) + sizeof(KEY_VALUE_PARTIAL_INFORMATION)];

            
                KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;

            
                OBJECT_ATTRIBUTES attr;

            
                UNICODE_STRING nameW;

            
                DWORD dummy;

            
                ULONG disp;

            
                HKEY hkey_old, hkey_env;


                attr.Length = sizeof(attr);

            
                attr.RootDirectory = 0;

            
                attr.ObjectName = &nameW;

            
                attr.Attributes = 0;

            
                attr.SecurityDescriptor = NULL;

            
                attr.SecurityQualityOfService = NULL;

            
                RtlInitUnicodeString( &nameW, wineW );


                if (NtOpenKey( &hkey_old, KEY_ALL_ACCESS, &attr ) != STATUS_SUCCESS) return;


                attr.RootDirectory = hkey_current_user;

            
                RtlInitUnicodeString( &nameW, envW );

            
                if (NtCreateKey( &hkey_env, KEY_ALL_ACCESS, &attr, 0, NULL, 0, &disp ))

            
                {

            
                    NtClose( hkey_old );

            
                    return;

            
                }


                /* Test for existence of TEMP */

            
                RtlInitUnicodeString( &nameW, tempW );

            
                if (NtQueryValueKey(hkey_env, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))

            
                {

            
                    /* convert TEMP */

            
                    RtlInitUnicodeString( &nameW, tempW );

            
                    if (!NtQueryValueKey( hkey_old, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))

            
                    {

            
                        NtSetValueKey( hkey_env, &nameW, 0, info->Type, info->Data, info->DataLength );

            
                        RtlInitUnicodeString( &nameW, tmpW );

            
                        NtSetValueKey( hkey_env, &nameW, 0, info->Type, info->Data, info->DataLength );

            
                        MESSAGE( "Converted temp dir to new entry HKCU\\Environment \"TEMP\" = %s\n",

            
                                debugstr_w( (WCHAR*)info->Data ) );

            
                    }

            
                }


                /* Test for existence of PATH */

            
                RtlInitUnicodeString( &nameW, pathW );

            
                if (NtQueryValueKey(hkey_env, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))

            
                {

            
                    /* convert PATH */

            
                    RtlInitUnicodeString( &nameW, pathW );

            
                    if (!NtQueryValueKey( hkey_old, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))

            
                    {

            
                        NtSetValueKey( hkey_env, &nameW, 0, info->Type, info->Data, info->DataLength );

            
                        MESSAGE( "Converted path dir to new entry HKCU\\Environment \"PATH\" = %s\n",

            
                                debugstr_w( (WCHAR*)info->Data ) );

            
                    }

            
                }


                /* Test for existence of USERPROFILE */

            
                RtlInitUnicodeString( &nameW, userprofileW );

            
                if (NtQueryValueKey(hkey_env, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))

            
                {

            
                    /* convert USERPROFILE */

            
                    RtlInitUnicodeString( &nameW, profileW );

            
                    if (!NtQueryValueKey( hkey_old, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))

            
                    {

            
                        RtlInitUnicodeString( &nameW, userprofileW );

            
                        NtSetValueKey( hkey_env, &nameW, 0, info->Type, info->Data, info->DataLength );

            
                        MESSAGE( "Converted profile dir to new entry HKCU\\Environment \"USERPROFILE\" = %s\n",

            
                                debugstr_w( (WCHAR*)info->Data ) );

            
                    }

            
                }


                /* Test for existence of windir */

            
                RtlInitUnicodeString( &nameW, windirW );

            
                if (NtQueryValueKey(hkey_env, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))

            
                {

            
                    /* convert windir */

            
                    RtlInitUnicodeString( &nameW, windowsW );

            
                    if (!NtQueryValueKey( hkey_old, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))

            
                    {

            
                        RtlInitUnicodeString( &nameW, windirW );

            
                        NtSetValueKey( hkey_env, &nameW, 0, info->Type, info->Data, info->DataLength );

            
                        RtlInitUnicodeString( &nameW, systemrootW );

            
                        NtSetValueKey( hkey_env, &nameW, 0, info->Type, info->Data, info->DataLength );

            
                        MESSAGE( "Converted windows dir to new entry HKCU\\Environment \"windir\" = %s\n",

            
                                debugstr_w( (WCHAR*)info->Data ) );

            
                    }

            
                }


                /* Test for existence of winsysdir */

            
                RtlInitUnicodeString( &nameW, winsysdirW );

            
                if (NtQueryValueKey(hkey_env, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))

            
                {

            
                    /* convert winsysdir */

            
                    RtlInitUnicodeString( &nameW, systemW );

            
                    if (!NtQueryValueKey( hkey_old, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))

            
                    {

            
                        RtlInitUnicodeString( &nameW, winsysdirW );

            
                        NtSetValueKey( hkey_env, &nameW, 0, info->Type, info->Data, info->DataLength );

            
                        MESSAGE( "Converted system dir to new entry HKCU\\Environment \"winsysdir\" = %s\n",

            
                                debugstr_w( (WCHAR*)info->Data ) );

            
                    }

            
                }

            
                NtClose( hkey_old );

            
                NtClose( hkey_env );

            
            }


            /* load all registry (native and global and home) */

            
            void SHELL_LoadRegistry( void )

            
            {

            
                HKEY hkey_current_user;

            
                OBJECT_ATTRIBUTES attr;

            
                UNICODE_STRING nameW;

            
                ULONG dispos;


                TRACE("(void)\n");


                attr.Length = sizeof(attr);

            
                attr.RootDirectory = 0;

            
                attr.ObjectName = &nameW;

            
                attr.Attributes = 0;

            
                attr.SecurityDescriptor = NULL;

            
                attr.SecurityQualityOfService = NULL;


                dispos = allocate_default_keys();

            
                if (dispos == REG_OPENED_EXISTING_KEY)

            
                    return; /* someone else already loaded the registry */


                RtlOpenCurrentUser( KEY_ALL_ACCESS, &hkey_current_user );


                /* load home registries */


                SERVER_START_REQ( load_user_registries )

            
                {

            
                    req->hkey = hkey_current_user;

            
                    wine_server_call( req );

            
                }

            
                SERVER_END_REQ;


                /* create hardware registry branch */


                create_hardware_branch();


                /* convert keys from config file to new registry format */


                convert_drive_types();

            
                convert_environment( hkey_current_user );


                NtClose(hkey_current_user);

            
            }
	/*
	* Registry Functions
	*
	* Copyright 1996 Marcus Meissner
	* Copyright 1998 Matthew Becker
	* Copyright 1999 Sylvain St-Germain
	*
	* December 21, 1997 - Kevin Cozens
	* Fixed bugs in the _w95_loadreg() function. Added extra information
	* regarding the format of the Windows '95 registry files.
	*
	* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*
	* TODO
	* Security access
	* Option handling
	* Time for RegEnumKey, RegQueryInfoKey
	*/

	#include "config.h"
	#include "wine/port.h"

	#include <stdlib.h>
	#include <string.h>
	#include <stdarg.h>
	#include <stdio.h>
	#ifdef HAVE_UNISTD_H
	# include <unistd.h>
	#endif
	#include <errno.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <fcntl.h>
	#ifdef HAVE_SYS_IOCTL_H
	#include <sys/ioctl.h>
	#endif
	#ifdef HAVE_LINUX_HDREG_H
	# include <linux/hdreg.h>
	#endif

	#define NONAMELESSUNION
	#define NONAMELESSSTRUCT
	#include "ntstatus.h"
	#include "windef.h"
	#include "winbase.h"
	#include "winerror.h"
	#include "winioctl.h"
	#include "ntddscsi.h"

	#include "wine/library.h"
	#include "wine/server.h"
	#include "wine/unicode.h"

	#include "wine/debug.h"

	WINE_DEFAULT_DEBUG_CHANNEL(reg);


	/******************************************************************************
	* allocate_default_keys [Internal]
	* Registry initialisation, allocates some default keys.
	*/
	static ULONG allocate_default_keys(void)
	{
	static const WCHAR StatDataW[] = {'D','y','n','D','a','t','a','\\',
	'P','e','r','f','S','t','a','t','s','\\',
	'S','t','a','t','D','a','t','a',0};
	static const WCHAR ConfigManagerW[] = {'D','y','n','D','a','t','a','\\',
	'C','o','n','f','i','g',' ','M','a','n','a','g','e','r','\\',
	'E','n','u','m',0};
	static const WCHAR Clone[] = {'M','a','c','h','i','n','e','\\',
	'S','y','s','t','e','m','\\',
	'C','l','o','n','e',0};
	HKEY hkey;
	ULONG dispos;
	OBJECT_ATTRIBUTES attr;
	UNICODE_STRING nameW;

	attr.Length = sizeof(attr);
	attr.RootDirectory = 0;
	attr.ObjectName = &nameW;
	attr.Attributes = 0;
	attr.SecurityDescriptor = NULL;
	attr.SecurityQualityOfService = NULL;

	RtlInitUnicodeString( &nameW, StatDataW );
	if (!NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, &dispos )) NtClose( hkey );
	if (dispos == REG_OPENED_EXISTING_KEY)
	return dispos; /* someone else already loaded the registry */

	RtlInitUnicodeString( &nameW, ConfigManagerW );
	if (!NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL )) NtClose( hkey );

	/* this key is generated when the nt-core booted successfully */
	RtlInitUnicodeString( &nameW, Clone );
	if (!NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL )) NtClose( hkey );

	return dispos;
	}


	/******************************************************************
	* init_cdrom_registry
	*
	* Initializes registry to contain scsi info about the cdrom in NT.
	* All devices (even not real scsi ones) have this info in NT.
	* TODO: for now it only works for non scsi devices
	* NOTE: programs usually read these registry entries after sending the
	* IOCTL_SCSI_GET_ADDRESS ioctl to the cdrom
	*/
	static void init_cdrom_registry( HANDLE handle )
	{
	OBJECT_ATTRIBUTES attr;
	UNICODE_STRING nameW;
	WCHAR dataW[50];
	DWORD lenW;
	char buffer[40];
	DWORD value;
	const char *data;
	HKEY scsiKey;
	HKEY portKey;
	HKEY busKey;
	HKEY targetKey;
	DWORD disp;
	IO_STATUS_BLOCK io;
	SCSI_ADDRESS scsi_addr;

	if (NtDeviceIoControlFile( handle, 0, NULL, NULL, &io, IOCTL_SCSI_GET_ADDRESS,
	NULL, 0, &scsi_addr, sizeof(scsi_addr) ))
	return;

	attr.Length = sizeof(attr);
	attr.RootDirectory = 0;
	attr.ObjectName = &nameW;
	attr.Attributes = 0;
	attr.SecurityDescriptor = NULL;
	attr.SecurityQualityOfService = NULL;

	/* Ensure there is Scsi key */
	if (!RtlCreateUnicodeStringFromAsciiz( &nameW, "Machine\\HARDWARE\\DEVICEMAP\\Scsi" ) \|\|
	NtCreateKey( &scsiKey, KEY_ALL_ACCESS, &attr, 0,
	NULL, REG_OPTION_VOLATILE, &disp ))
	{
	ERR("Cannot create DEVICEMAP\\Scsi registry key\n" );
	return;
	}
	RtlFreeUnicodeString( &nameW );

	snprintf(buffer,sizeof(buffer),"Scsi Port %d",scsi_addr.PortNumber);
	attr.RootDirectory = scsiKey;
	if (!RtlCreateUnicodeStringFromAsciiz( &nameW, buffer ) \|\|
	NtCreateKey( &portKey, KEY_ALL_ACCESS, &attr, 0,
	NULL, REG_OPTION_VOLATILE, &disp ))
	{
	ERR("Cannot create DEVICEMAP\\Scsi Port registry key\n" );
	return;
	}
	RtlFreeUnicodeString( &nameW );

	RtlCreateUnicodeStringFromAsciiz( &nameW, "Driver" );
	data = "atapi";
	RtlMultiByteToUnicodeN( dataW, 50, &lenW, data, strlen(data));
	NtSetValueKey( portKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );
	RtlFreeUnicodeString( &nameW );
	value = 10;
	RtlCreateUnicodeStringFromAsciiz( &nameW, "FirstBusTimeScanInMs" );
	NtSetValueKey( portKey,&nameW, 0, REG_DWORD, (BYTE *)&value, sizeof(DWORD));
	RtlFreeUnicodeString( &nameW );
	value = 0;
	#ifdef HDIO_GET_DMA
	{
	int fd, dma;
	if (!wine_server_handle_to_fd( handle, 0, &fd, NULL ))
	{
	if (ioctl(fd,HDIO_GET_DMA, &dma) != -1) value = dma;
	wine_server_release_fd( handle, fd );
	}
	}
	#endif
	RtlCreateUnicodeStringFromAsciiz( &nameW, "DMAEnabled" );
	NtSetValueKey( portKey,&nameW, 0, REG_DWORD, (BYTE *)&value, sizeof(DWORD));
	RtlFreeUnicodeString( &nameW );

	snprintf(buffer,40,"Scsi Bus %d", scsi_addr.PathId);
	attr.RootDirectory = portKey;
	if (!RtlCreateUnicodeStringFromAsciiz( &nameW, buffer ) \|\|
	NtCreateKey( &busKey, KEY_ALL_ACCESS, &attr, 0,
	NULL, REG_OPTION_VOLATILE, &disp ))
	{
	ERR("Cannot create DEVICEMAP\\Scsi Port\\Scsi Bus registry key\n" );
	return;
	}
	RtlFreeUnicodeString( &nameW );

	attr.RootDirectory = busKey;
	if (!RtlCreateUnicodeStringFromAsciiz( &nameW, "Initiator Id 255" ) \|\|
	NtCreateKey( &targetKey, KEY_ALL_ACCESS, &attr, 0,
	NULL, REG_OPTION_VOLATILE, &disp ))
	{
	ERR("Cannot create DEVICEMAP\\Scsi Port\\Scsi Bus\\Initiator Id 255 registry key\n" );
	return;
	}
	RtlFreeUnicodeString( &nameW );
	NtClose( targetKey );

	snprintf(buffer,40,"Target Id %d", scsi_addr.TargetId);
	attr.RootDirectory = busKey;
	if (!RtlCreateUnicodeStringFromAsciiz( &nameW, buffer ) \|\|
	NtCreateKey( &targetKey, KEY_ALL_ACCESS, &attr, 0,
	NULL, REG_OPTION_VOLATILE, &disp ))
	{
	ERR("Cannot create DEVICEMAP\\Scsi Port\\Scsi Bus 0\\Target Id registry key\n" );
	return;
	}
	RtlFreeUnicodeString( &nameW );

	RtlCreateUnicodeStringFromAsciiz( &nameW, "Type" );
	data = "CdRomPeripheral";
	RtlMultiByteToUnicodeN( dataW, 50, &lenW, data, strlen(data));
	NtSetValueKey( targetKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );
	RtlFreeUnicodeString( &nameW );
	/* FIXME - maybe read the real identifier?? */
	RtlCreateUnicodeStringFromAsciiz( &nameW, "Identifier" );
	data = "Wine CDROM";
	RtlMultiByteToUnicodeN( dataW, 50, &lenW, data, strlen(data));
	NtSetValueKey( targetKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );
	RtlFreeUnicodeString( &nameW );
	/* FIXME - we always use Cdrom0 - do not know about the nt behaviour */
	RtlCreateUnicodeStringFromAsciiz( &nameW, "DeviceName" );
	data = "Cdrom0";
	RtlMultiByteToUnicodeN( dataW, 50, &lenW, data, strlen(data));
	NtSetValueKey( targetKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );
	RtlFreeUnicodeString( &nameW );

	NtClose( targetKey );
	NtClose( busKey );
	NtClose( portKey );
	NtClose( scsiKey );
	}


	/* create the hardware registry branch */
	static void create_hardware_branch(void)
	{
	int i;
	HANDLE handle;
	char drive[] = "\\\\.\\A:";

	/* create entries for cdroms */
	for (i = 0; i < 26; i++)
	{
	drive[4] = 'A' + i;
	handle = CreateFileA( drive, 0, 0, NULL, OPEN_EXISTING, 0, 0 );
	if (handle == INVALID_HANDLE_VALUE) continue;
	init_cdrom_registry( handle );
	CloseHandle( handle );
	}
	}


	/* convert the drive type entries from the old format to the new one */
	static void convert_drive_types(void)
	{
	static const WCHAR TypeW[] = {'T','y','p','e',0};
	static const WCHAR drive_types_keyW[] = {'M','a','c','h','i','n','e','\\',
	'S','o','f','t','w','a','r','e','\\',
	'W','i','n','e','\\',
	'D','r','i','v','e','s',0 };
	WCHAR driveW[] = {'M','a','c','h','i','n','e','\\','S','o','f','t','w','a','r','e','\\',
	'W','i','n','e','\\','W','i','n','e','\\',
	'C','o','n','f','i','g','\\','D','r','i','v','e',' ','A',0};
	char tmp[32*sizeof(WCHAR) + sizeof(KEY_VALUE_PARTIAL_INFORMATION)];
	OBJECT_ATTRIBUTES attr;
	UNICODE_STRING nameW;
	DWORD dummy;
	ULONG disp;
	HKEY hkey_old, hkey_new;
	int i;

	attr.Length = sizeof(attr);
	attr.RootDirectory = 0;
	attr.ObjectName = &nameW;
	attr.Attributes = 0;
	attr.SecurityDescriptor = NULL;
	attr.SecurityQualityOfService = NULL;
	RtlInitUnicodeString( &nameW, drive_types_keyW );

	if (NtCreateKey( &hkey_new, KEY_ALL_ACCESS, &attr, 0, NULL, 0, &disp )) return;
	if (disp != REG_CREATED_NEW_KEY)
	{
	NtClose( hkey_new );
	return;
	}

	for (i = 0; i < 26; i++)
	{
	RtlInitUnicodeString( &nameW, driveW );
	nameW.Buffer[(nameW.Length / sizeof(WCHAR)) - 1] = 'A' + i;
	if (NtOpenKey( &hkey_old, KEY_ALL_ACCESS, &attr ) != STATUS_SUCCESS) continue;
	RtlInitUnicodeString( &nameW, TypeW );
	if (!NtQueryValueKey( hkey_old, &nameW, KeyValuePartialInformation, tmp, sizeof(tmp), &dummy ))
	{
	WCHAR valueW[] = {'A',':',0};
	WCHAR type = (WCHAR )((KEY_VALUE_PARTIAL_INFORMATION *)tmp)->Data;

	valueW[0] = 'A' + i;
	RtlInitUnicodeString( &nameW, valueW );
	NtSetValueKey( hkey_new, &nameW, 0, REG_SZ, type, (strlenW(type) + 1) * sizeof(WCHAR) );
	MESSAGE( "Converted drive type to new entry HKLM\\Software\\Wine\\Drives \"%c:\" = %s\n",
	'A' + i, debugstr_w(type) );
	}
	NtClose( hkey_old );
	}
	NtClose( hkey_new );
	}


	/* convert the environment variable entries from the old format to the new one */
	static void convert_environment( HKEY hkey_current_user )
	{
	static const WCHAR wineW[] = {'M','a','c','h','i','n','e','\\',
	'S','o','f','t','w','a','r','e','\\',
	'W','i','n','e','\\','W','i','n','e','\\',
	'C','o','n','f','i','g','\\','W','i','n','e',0};
	static const WCHAR windowsW[] = {'w','i','n','d','o','w','s',0};
	static const WCHAR systemW[] = {'s','y','s','t','e','m',0};
	static const WCHAR windirW[] = {'w','i','n','d','i','r',0};
	static const WCHAR systemrootW[] = {'S','y','s','t','e','m','r','o','o','t',0};
	static const WCHAR winsysdirW[] = {'w','i','n','s','y','s','d','i','r',0};
	static const WCHAR envW[] = {'E','n','v','i','r','o','n','m','e','n','t',0};
	static const WCHAR tempW[] = {'T','E','M','P',0};
	static const WCHAR tmpW[] = {'T','M','P',0};
	static const WCHAR pathW[] = {'P','A','T','H',0};
	static const WCHAR profileW[] = {'p','r','o','f','i','l','e',0};
	static const WCHAR userprofileW[] = {'U','S','E','R','P','R','O','F','I','L','E',0};

	char buffer[1024*sizeof(WCHAR) + sizeof(KEY_VALUE_PARTIAL_INFORMATION)];
	KEY_VALUE_PARTIAL_INFORMATION info = (KEY_VALUE_PARTIAL_INFORMATION )buffer;
	OBJECT_ATTRIBUTES attr;
	UNICODE_STRING nameW;
	DWORD dummy;
	ULONG disp;
	HKEY hkey_old, hkey_env;

	attr.Length = sizeof(attr);
	attr.RootDirectory = 0;
	attr.ObjectName = &nameW;
	attr.Attributes = 0;
	attr.SecurityDescriptor = NULL;
	attr.SecurityQualityOfService = NULL;
	RtlInitUnicodeString( &nameW, wineW );

	if (NtOpenKey( &hkey_old, KEY_ALL_ACCESS, &attr ) != STATUS_SUCCESS) return;

	attr.RootDirectory = hkey_current_user;
	RtlInitUnicodeString( &nameW, envW );
	if (NtCreateKey( &hkey_env, KEY_ALL_ACCESS, &attr, 0, NULL, 0, &disp ))
	{
	NtClose( hkey_old );
	return;
	}

	/* Test for existence of TEMP */
	RtlInitUnicodeString( &nameW, tempW );
	if (NtQueryValueKey(hkey_env, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))
	{
	/* convert TEMP */
	RtlInitUnicodeString( &nameW, tempW );
	if (!NtQueryValueKey( hkey_old, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))
	{
	NtSetValueKey( hkey_env, &nameW, 0, info->Type, info->Data, info->DataLength );
	RtlInitUnicodeString( &nameW, tmpW );
	NtSetValueKey( hkey_env, &nameW, 0, info->Type, info->Data, info->DataLength );
	MESSAGE( "Converted temp dir to new entry HKCU\\Environment \"TEMP\" = %s\n",
	debugstr_w( (WCHAR*)info->Data ) );
	}
	}

	/* Test for existence of PATH */
	RtlInitUnicodeString( &nameW, pathW );
	if (NtQueryValueKey(hkey_env, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))
	{
	/* convert PATH */
	RtlInitUnicodeString( &nameW, pathW );
	if (!NtQueryValueKey( hkey_old, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))
	{
	NtSetValueKey( hkey_env, &nameW, 0, info->Type, info->Data, info->DataLength );
	MESSAGE( "Converted path dir to new entry HKCU\\Environment \"PATH\" = %s\n",
	debugstr_w( (WCHAR*)info->Data ) );
	}
	}

	/* Test for existence of USERPROFILE */
	RtlInitUnicodeString( &nameW, userprofileW );
	if (NtQueryValueKey(hkey_env, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))
	{
	/* convert USERPROFILE */
	RtlInitUnicodeString( &nameW, profileW );
	if (!NtQueryValueKey( hkey_old, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))
	{
	RtlInitUnicodeString( &nameW, userprofileW );
	NtSetValueKey( hkey_env, &nameW, 0, info->Type, info->Data, info->DataLength );
	MESSAGE( "Converted profile dir to new entry HKCU\\Environment \"USERPROFILE\" = %s\n",
	debugstr_w( (WCHAR*)info->Data ) );
	}
	}

	/* Test for existence of windir */
	RtlInitUnicodeString( &nameW, windirW );
	if (NtQueryValueKey(hkey_env, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))
	{
	/* convert windir */
	RtlInitUnicodeString( &nameW, windowsW );
	if (!NtQueryValueKey( hkey_old, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))
	{
	RtlInitUnicodeString( &nameW, windirW );
	NtSetValueKey( hkey_env, &nameW, 0, info->Type, info->Data, info->DataLength );
	RtlInitUnicodeString( &nameW, systemrootW );
	NtSetValueKey( hkey_env, &nameW, 0, info->Type, info->Data, info->DataLength );
	MESSAGE( "Converted windows dir to new entry HKCU\\Environment \"windir\" = %s\n",
	debugstr_w( (WCHAR*)info->Data ) );
	}
	}

	/* Test for existence of winsysdir */
	RtlInitUnicodeString( &nameW, winsysdirW );
	if (NtQueryValueKey(hkey_env, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))
	{
	/* convert winsysdir */
	RtlInitUnicodeString( &nameW, systemW );
	if (!NtQueryValueKey( hkey_old, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &dummy ))
	{
	RtlInitUnicodeString( &nameW, winsysdirW );
	NtSetValueKey( hkey_env, &nameW, 0, info->Type, info->Data, info->DataLength );
	MESSAGE( "Converted system dir to new entry HKCU\\Environment \"winsysdir\" = %s\n",
	debugstr_w( (WCHAR*)info->Data ) );
	}
	}
	NtClose( hkey_old );
	NtClose( hkey_env );
	}


	/* load all registry (native and global and home) */
	void SHELL_LoadRegistry( void )
	{
	HKEY hkey_current_user;
	OBJECT_ATTRIBUTES attr;
	UNICODE_STRING nameW;
	ULONG dispos;

	TRACE("(void)\n");

	attr.Length = sizeof(attr);
	attr.RootDirectory = 0;
	attr.ObjectName = &nameW;
	attr.Attributes = 0;
	attr.SecurityDescriptor = NULL;
	attr.SecurityQualityOfService = NULL;

	dispos = allocate_default_keys();
	if (dispos == REG_OPENED_EXISTING_KEY)
	return; /* someone else already loaded the registry */

	RtlOpenCurrentUser( KEY_ALL_ACCESS, &hkey_current_user );

	/* load home registries */

	SERVER_START_REQ( load_user_registries )
	{
	req->hkey = hkey_current_user;
	wine_server_call( req );
	}
	SERVER_END_REQ;

	/* create hardware registry branch */

	create_hardware_branch();

	/* convert keys from config file to new registry format */

	convert_drive_types();
	convert_environment( hkey_current_user );

	NtClose(hkey_current_user);
	}