ClusterRegistryConfigurationProvider.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / TransactionBridge / Microsoft / Transactions / Wsat / Clusters / ClusterRegistryConfigurationProvider.cs / 1 / ClusterRegistryConfigurationProvider.cs

                            //------------------------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------

// Implement the ConfigurationProvider base class for the cluster registry 

using System; 
using System.Collections.Generic; 
using System.Diagnostics;
using System.Runtime.InteropServices; 
using System.Security.AccessControl;
using System.Text;
using System.ServiceModel.Diagnostics;
 
using Microsoft.Transactions.Bridge;
using Microsoft.Transactions.Wsat.Messaging; 
using Microsoft.Transactions.Wsat.Protocol; 
using Microsoft.Win32;
 
namespace Microsoft.Transactions.Wsat.Clusters
{
    class ClusterRegistryConfigurationProvider : ConfigurationProvider
    { 
        SafeHKey hKey;
 
        public ClusterRegistryConfigurationProvider(SafeHResource hResource) 
        {
            this.hKey = SafeNativeMethods.GetClusterResourceKey(hResource, 
                                                                RegistryRights.ReadKey |
                                                                RegistryRights.EnumerateSubKeys |
                                                                RegistryRights.QueryValues);
            if (this.hKey.IsInvalid) 
            {
                int gle = Marshal.GetLastWin32Error(); 
                this.hKey.SetHandleAsInvalid(); 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
                    new ConfigurationProviderException(SR.GetString(SR.GetClusterResourceKeyFailed, gle))); 
            }

            if (DebugTrace.Verbose)
                DebugTrace.Trace(TraceLevel.Verbose, "Opened cluster resource key"); 
        }
 
        ClusterRegistryConfigurationProvider(SafeHKey rootKey, string subKey) 
        {
            // If the rootKey is null or invalid, we just nod and return default values 
            if (rootKey != null && !rootKey.IsInvalid)
            {
                int ret = SafeNativeMethods.ClusterRegOpenKey(rootKey,
                                                              subKey, 
                                                              RegistryRights.ReadKey |
                                                              RegistryRights.EnumerateSubKeys | 
                                                              RegistryRights.QueryValues, 
                                                              out this.hKey);
                if (ret != SafeNativeMethods.ERROR_SUCCESS) 
                {
                    Utility.CloseInvalidOutSafeHandle(this.hKey);
                    if (ret != SafeNativeMethods.ERROR_FILE_NOT_FOUND)
                    { 
                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
                            new ConfigurationProviderException(SR.GetString(SR.ClusterRegOpenKeyFailed, ret))); 
                    } 
                }
 
                if (DebugTrace.Verbose)
                    DebugTrace.Trace(TraceLevel.Verbose,
                                     "ClusterRegOpenKey for {0} returned {1}",
                                     subKey, ret); 
            }
        } 
 
        public override void Dispose()
        { 
            if (this.hKey != null && !this.hKey.IsInvalid)
                this.hKey.Dispose();
        }
 
        byte[] QueryValue(string value, RegistryValueKind valueType)
        { 
            if (this.hKey == null || this.hKey.IsInvalid) 
                return null;
 
            RegistryValueKind type;
            uint cb = 0;
            int ret = SafeNativeMethods.ClusterRegQueryValue(this.hKey,
                                                             value, 
                                                             out type,
                                                             null, 
                                                             ref cb); 
            if (ret == SafeNativeMethods.ERROR_SUCCESS ||
                ret == SafeNativeMethods.ERROR_MORE_DATA) 
            {
                if (valueType != type)
                    return null;
 
                byte[] buffer = new byte[cb];
                ret = SafeNativeMethods.ClusterRegQueryValue(this.hKey, 
                                                             value, 
                                                             out type,
                                                             buffer, 
                                                             ref cb);

                if (ret == SafeNativeMethods.ERROR_SUCCESS)
                { 
                    if (valueType != type)
                        return null; 
 
                    return buffer;
                } 
            }

            if (DebugTrace.Verbose)
                DebugTrace.Trace(TraceLevel.Verbose, 
                                 "ClusterRegQueryValue for {0} returned {1}",
                                 value, ret); 
 
            if (ret == SafeNativeMethods.ERROR_FILE_NOT_FOUND)
                return null; 

            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
                new ConfigurationProviderException(SR.GetString(SR.ClusterRegQueryValueFailed, ret)));
        } 

        public override int ReadInteger(string value, int defaultValue) 
        { 
            byte[] buffer = QueryValue(value, RegistryValueKind.DWord);
            if (buffer == null) 
                return defaultValue;

            return (int)BitConverter.ToUInt32(buffer, 0);
        } 

        public override string ReadString(string value, string defaultValue) 
        { 
            byte[] buffer = QueryValue(value, RegistryValueKind.String);
            if (buffer == null) 
                return defaultValue;

            try
            { 
                return Encoding.Unicode.GetString(buffer, 0, buffer.Length - 2);
            } 
            catch (ArgumentException e) 
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( 
                    new ConfigurationProviderException(SR.GetString(SR.ClusterRegQueryValueInvalidResults, value), e));
            }
        }
 
        public override string[] ReadMultiString(string value, string[] defaultValue)
        { 
            byte[] buffer = QueryValue(value, RegistryValueKind.MultiString); 
            if (buffer == null)
                return defaultValue; 

            List list = new List(5);
            string item;
            int index = 0; 
            while ((item = GetStringFromMultiSz(value, buffer, ref index)) != null)
            { 
                list.Add(item); 
            }
 
            return list.ToArray();
        }

        public override ConfigurationProvider OpenKey(string key) 
        {
            return new ClusterRegistryConfigurationProvider(this.hKey, key); 
        } 

        string GetStringFromMultiSz(string value, byte[] buffer, ref int index) 
        {
            // E.g. abc\0def\0\0
            // This loop terminates when it finds a null terminating character
            // The index will be left pointing at the first null terminator it finds 
            int start = index;
            for (; 
                 index < buffer.Length - 1 && BitConverter.ToChar(buffer, index) != 0; 
                 index += 2) ;
 
            // If we found no valid characters, we're done
            if (start == index)
                return null;
 
            // Skip past the null terminator at which we stopped
            index += 2; 
 
            // Convert the characters we found to a string
            try 
            {
                return Encoding.Unicode.GetString(buffer, start, index - start - 2);
            }
            catch (ArgumentException e) 
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( 
                    new ConfigurationProviderException(SR.GetString(SR.ClusterRegQueryValueInvalidResults, value), e)); 
            }
        } 
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK