示例#1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>

        public WowRegistryKey OpenSubKey(string name)
        {
            WowRegistryKey key = null;
            IntPtr         hKey;

            if (regKey == null)
            {
                int samFlags = WowRegistry.KEY_QUERY_VALUE | WowRegistry.KEY_ENUMERATE_SUB_KEYS;

                // [SMC 20090811] Since WowRegistry is taking care of opening the proper key
                // we shouldn't need to redirect again here...

                //if (redirected)
                //    samFlags |= WowRegistry.KEY_WOW64_64KEY;
                //else
                //    samFlags |= WowRegistry.KEY_WOW64_32KEY;

                if (WowRegistry.ForceRedirection)
                {
                    samFlags |= WowRegistry.KEY_WOW64_32KEY;
                }

                int result = WowRegistry.RegOpenKeyEx(
                    this.intKey,
                    name,
                    0,
                    samFlags,
                    out hKey);

                if (result != WowRegistry.ERR_KEY_NOT_FOUND)
                {
                    if (result != 0)
                    {
                        throw new Exception(
                                  String.Format("WowRegistryKey.OpenSubKey(), error={0}", result));
                    }

                    key = new WowRegistryKey(hKey, null, this.hive, name);
                }
            }
            else
            {
                RegistryKey subKey = regKey.OpenSubKey(name);

                if (subKey != null)
                {
                    string subName = this.name + "\\" + name;

                    hKey = new IntPtr(subKey.GetHashCode());
                    key  = new WowRegistryKey(hKey, subKey, this.hive, subName);
                }
            }

            return(key);
        }
示例#2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>

        public WowRegistryKey OpenSubKey(string name)
        {
            WowRegistryKey key = null;
            IntPtr         hKey;

            if (regKey == null)
            {
                int samFlags = WowRegistry.KEY_QUERY_VALUE | WowRegistry.KEY_ENUMERATE_SUB_KEYS;
                if (redirected)
                {
                    samFlags |= WowRegistry.KEY_WOW64_64KEY;
                }
                else
                {
                    samFlags |= WowRegistry.KEY_WOW64_32KEY;
                }

                int result = WowRegistry.RegOpenKeyEx(
                    this.intKey,
                    name,
                    0,
                    samFlags,
                    out hKey);

                if (result != WowRegistry.ERR_KEY_NOT_FOUND)
                {
                    if (result != 0)
                    {
                        throw new Exception(
                                  String.Format("WowRegistryKey.OpenSubKey(), error={0}", result));
                    }

                    key = new WowRegistryKey(hKey, null, this.hive, name);
                }
            }
            else
            {
                RegistryKey subKey = regKey.OpenSubKey(name);

                if (subKey != null)
                {
                    string subName = this.name + "\\" + name;

                    hKey = new IntPtr(subKey.GetHashCode());
                    key  = new WowRegistryKey(hKey, subKey, this.hive, subName);
                }
            }

            return(key);
        }
示例#3
0
        /// <summary>
        /// Initiates a WOW Registry session by opening a new WowRegistryKey, optionally
        /// redirecting from default (64-bit) hive to redirected (32-bit) hive.
        /// </summary>
        /// <param name="hive">The Registry hive containing the key.</param>
        /// <param name="keyName">The name of the key beneath the specified hive.</param>
        /// <param name="redirect"><b>true</b> to redirect to 32-bit hive.</param>
        /// <returns>A WowRegistryKey used to access the data and subkeys of the key.</returns>

        public static WowRegistryKey Open(RegistryHive hive, string keyName, bool redirect)
        {
            WowRegistryKey key  = null;
            IntPtr         hKey = IntPtr.Zero;

            if (WowEnvironment.Is64BitMachine)
            {
                IntPtr hiveId = IntPtr.Zero;

                switch (hive)
                {
                case RegistryHive.ClassesRoot: hiveId = HKEY_CLASSES_ROOT; break;

                case RegistryHive.CurrentConfig: hiveId = HKEY_CURRENT_CONFIG; break;

                case RegistryHive.CurrentUser: hiveId = HKEY_CURRENT_USER; break;

                case RegistryHive.DynData: hiveId = HKEY_DYN_DATA; break;

                case RegistryHive.LocalMachine: hiveId = HKEY_LOCAL_MACHINE; break;

                case RegistryHive.PerformanceData: hiveId = HKEY_PERFORMANCE_DATA; break;

                case RegistryHive.Users: hiveId = HKEY_USERS; break;
                }

                int samFlags = KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS;

                if (redirect)
                {
                    samFlags |= WowRegistry.KEY_WOW64_32KEY;
                }
                else if (WowEnvironment.IsWowProcess)
                {
                    samFlags |= WowRegistry.KEY_WOW64_64KEY;
                }

                int result = RegOpenKeyEx(
                    hiveId,
                    keyName,
                    0,
                    samFlags,
                    out hKey);

                if (result != ERR_KEY_NOT_FOUND)
                {
                    if (result != 0)
                    {
                        throw new Exception(
                                  String.Format("WowRegistry.Open(), error={0}", result));
                    }

                    key = new WowRegistryKey(hKey, null, hive, keyName);
                }
            }
            else
            {
                RegistryKey regKey = null;

                if ((keyName == null) || keyName.Equals(String.Empty))
                {
                    switch (hive)
                    {
                    case RegistryHive.ClassesRoot: regKey = Registry.ClassesRoot; break;

                    case RegistryHive.CurrentConfig: regKey = Registry.CurrentConfig; break;

                    case RegistryHive.CurrentUser: regKey = Registry.CurrentUser; break;

                    case RegistryHive.LocalMachine: regKey = Registry.LocalMachine; break;

                    case RegistryHive.PerformanceData: regKey = Registry.PerformanceData; break;

                    case RegistryHive.Users: regKey = Registry.Users; break;
                    }

                    hKey = new IntPtr(regKey.GetHashCode());
                    key  = new WowRegistryKey(hKey, regKey, hive, keyName);
                }
                else
                {
                    regKey = Registry.LocalMachine.OpenSubKey(keyName);
                    if (regKey != null)
                    {
                        hKey = new IntPtr(regKey.GetHashCode());
                        key  = new WowRegistryKey(hKey, regKey, hive, keyName);
                    }
                }
            }

            return(key);
        }