Errors.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Base / MS / Internal / Security / RightsManagement / Errors.cs / 1305600 / Errors.cs
                        

                        
                            //------------------------------------------------------------------------------ 
//
// 
//    Copyright (c) Microsoft Corporation.  All rights reserved.
//  
//
// Description: 
//  This file contains Error Constants defined by the promethium SDK and an exception mapping mechanism 
//
// 
// History:
//  06/13/2005: IgorBel:  Initial implementation.
//
//----------------------------------------------------------------------------- 

using System; 
using System.Runtime.InteropServices; 
using System.Security;
using System.Security.Permissions; 
using System.Security.RightsManagement;
using System.Windows;

using SR=MS.Internal.WindowsBase.SR; 
using SRID=MS.Internal.WindowsBase.SRID;
 
 
// Enable presharp pragma warning suppress directives.
#pragma warning disable 1634, 1691 

namespace MS.Internal.Security.RightsManagement
{
    internal static class Errors 
    {
        internal static string GetLocalizedFailureCodeMessageWithDefault(RightsManagementFailureCode failureCode) 
        { 
            string errorMessage = GetLocalizedFailureCodeMessage(failureCode);
            if (errorMessage != null) 
            {
                return errorMessage;
            }
            else 
            {
                return SR.Get(SRID.RmExceptionGenericMessage); 
            } 
        }
 
        /// 
        /// This function throws the exception if hr doesn't indicate a success. In case of recognized
        /// Rights Management Failure code it will throw a RightsManagementException with an appropriate
        /// message. Otherwise, if code isn't recognized as Rights Management specific,  it will throw 
        /// RightsManagementException which has a COMException as an inner exception with the
        /// appropriate hr code. 
        ///  
        /// 
        ///     Critical: This code calls into ThrowExceptionForHr which has a link demand 
        ///     TreatAsSafe: The net effect is the same as throwing an exception from your app
        /// 
        [SecurityCritical, SecurityTreatAsSafe]
        internal static void ThrowOnErrorCode(int hr) 
        {
            // we can return if it is not a failure right away 
            // there is no reason to attempt to look-up codes and 
            // messages which is somewhat expensive in the case of success
            if (hr >=0) 
            {
                return;
            }
 
            string errorMessage = GetLocalizedFailureCodeMessage((RightsManagementFailureCode)hr);
            if (errorMessage != null) 
            { 
                throw new RightsManagementException((RightsManagementFailureCode)hr, errorMessage);
            } 
            else
            {
                try
                { 
                    // It seems that ThrowExceptionForHR is the most consistent way
                    // to get a platform representation of the unmanaged HR code 
                    Marshal.ThrowExceptionForHR(hr); 
                }
// disabling PreSharp false positive. In this case we are actually re-throwing the same exception 
// wrapped in a more specific message
#pragma warning disable 56500
                catch (Exception e)
                { 
                    // rethrow the exception as an inner exception of the RmExceptionGenericMessage
                    throw new RightsManagementException(SR.Get(SRID.RmExceptionGenericMessage), e); 
                } 
#pragma warning restore 56500
            } 
        }

        private static string GetLocalizedFailureCodeMessage(RightsManagementFailureCode failureCode)
        { 
            string result;
            switch (failureCode) 
            { 
                case RightsManagementFailureCode.InvalidLicense:
                    result=SRID.RmExceptionInvalidLicense; break; 
                case RightsManagementFailureCode.InfoNotInLicense:
                    result=SRID.RmExceptionInfoNotInLicense; break;
                case RightsManagementFailureCode.InvalidLicenseSignature:
                    result=SRID.RmExceptionInvalidLicenseSignature; break; 
                case RightsManagementFailureCode.EncryptionNotPermitted:
                    result=SRID.RmExceptionEncryptionNotPermitted; break; 
                case RightsManagementFailureCode.RightNotGranted: 
                    result=SRID.RmExceptionRightNotGranted; break;
                case RightsManagementFailureCode.InvalidVersion: 
                    result=SRID.RmExceptionInvalidVersion; break;
                case RightsManagementFailureCode.InvalidEncodingType:
                    result=SRID.RmExceptionInvalidEncodingType; break;
                case RightsManagementFailureCode.InvalidNumericalValue: 
                    result=SRID.RmExceptionInvalidNumericalValue; break;
                case RightsManagementFailureCode.InvalidAlgorithmType: 
                    result=SRID.RmExceptionInvalidAlgorithmType; break; 
                case RightsManagementFailureCode.EnvironmentNotLoaded:
                    result=SRID.RmExceptionEnvironmentNotLoaded; break; 
                case RightsManagementFailureCode.EnvironmentCannotLoad:
                    result=SRID.RmExceptionEnvironmentCannotLoad; break;
                case RightsManagementFailureCode.TooManyLoadedEnvironments:
                    result=SRID.RmExceptionTooManyLoadedEnvironments; break; 
                case RightsManagementFailureCode.IncompatibleObjects:
                    result=SRID.RmExceptionIncompatibleObjects; break; 
                case RightsManagementFailureCode.LibraryFail: 
                    result=SRID.RmExceptionLibraryFail; break;
                case RightsManagementFailureCode.EnablingPrincipalFailure: 
                    result=SRID.RmExceptionEnablingPrincipalFailure; break;
                case RightsManagementFailureCode.InfoNotPresent:
                    result=SRID.RmExceptionInfoNotPresent; break;
                case RightsManagementFailureCode.BadGetInfoQuery: 
                    result=SRID.RmExceptionBadGetInfoQuery; break;
                case RightsManagementFailureCode.KeyTypeUnsupported: 
                    result=SRID.RmExceptionKeyTypeUnsupported; break; 
                case RightsManagementFailureCode.CryptoOperationUnsupported:
                    result=SRID.RmExceptionCryptoOperationUnsupported; break; 
                case RightsManagementFailureCode.ClockRollbackDetected:
                    result=SRID.RmExceptionClockRollbackDetected; break;
                case RightsManagementFailureCode.QueryReportsNoResults:
                    result=SRID.RmExceptionQueryReportsNoResults; break; 
                case RightsManagementFailureCode.UnexpectedException:
                    result=SRID.RmExceptionUnexpectedException; break; 
                case RightsManagementFailureCode.BindValidityTimeViolated: 
                    result=SRID.RmExceptionBindValidityTimeViolated; break;
                case RightsManagementFailureCode.BrokenCertChain: 
                    result=SRID.RmExceptionBrokenCertChain; break;
                case RightsManagementFailureCode.BindPolicyViolation:
                    result=SRID.RmExceptionBindPolicyViolation; break;
                case RightsManagementFailureCode.ManifestPolicyViolation: 
                    result=SRID.RmExceptionManifestPolicyViolation; break;
                case RightsManagementFailureCode.BindRevokedLicense: 
                    result=SRID.RmExceptionBindRevokedLicense; break; 
                case RightsManagementFailureCode.BindRevokedIssuer:
                    result=SRID.RmExceptionBindRevokedIssuer; break; 
                case RightsManagementFailureCode.BindRevokedPrincipal:
                    result=SRID.RmExceptionBindRevokedPrincipal; break;
                case RightsManagementFailureCode.BindRevokedResource:
                    result=SRID.RmExceptionBindRevokedResource; break; 
                case RightsManagementFailureCode.BindRevokedModule:
                    result=SRID.RmExceptionBindRevokedModule; break; 
                case RightsManagementFailureCode.BindContentNotInEndUseLicense: 
                    result=SRID.RmExceptionBindContentNotInEndUseLicense; break;
                case RightsManagementFailureCode.BindAccessPrincipalNotEnabling: 
                    result=SRID.RmExceptionBindAccessPrincipalNotEnabling; break;
                case RightsManagementFailureCode.BindAccessUnsatisfied:
                    result=SRID.RmExceptionBindAccessUnsatisfied; break;
                case RightsManagementFailureCode.BindIndicatedPrincipalMissing: 
                    result=SRID.RmExceptionBindIndicatedPrincipalMissing; break;
                case RightsManagementFailureCode.BindMachineNotFoundInGroupIdentity: 
                    result=SRID.RmExceptionBindMachineNotFoundInGroupIdentity; break; 
                case RightsManagementFailureCode.LibraryUnsupportedPlugIn:
                    result=SRID.RmExceptionLibraryUnsupportedPlugIn; break; 
                case RightsManagementFailureCode.BindRevocationListStale:
                    result=SRID.RmExceptionBindRevocationListStale; break;
                case RightsManagementFailureCode.BindNoApplicableRevocationList:
                    result=SRID.RmExceptionBindNoApplicableRevocationList; break; 
                case RightsManagementFailureCode.InvalidHandle:
                    result=SRID.RmExceptionInvalidHandle; break; 
                case RightsManagementFailureCode.BindIntervalTimeViolated: 
                    result=SRID.RmExceptionBindIntervalTimeViolated; break;
                case RightsManagementFailureCode.BindNoSatisfiedRightsGroup: 
                    result=SRID.RmExceptionBindNoSatisfiedRightsGroup; break;
                case RightsManagementFailureCode.BindSpecifiedWorkMissing:
                    result=SRID.RmExceptionBindSpecifiedWorkMissing; break;
                case RightsManagementFailureCode.NoMoreData: 
                    result=SRID.RmExceptionNoMoreData; break;
                case RightsManagementFailureCode.LicenseAcquisitionFailed: 
                    result=SRID.RmExceptionLicenseAcquisitionFailed; break; 
                case RightsManagementFailureCode.IdMismatch:
                    result=SRID.RmExceptionIdMismatch; break; 
                case RightsManagementFailureCode.TooManyCertificates:
                    result=SRID.RmExceptionTooManyCertificates; break;
                case RightsManagementFailureCode.NoDistributionPointUrlFound:
                    result=SRID.RmExceptionNoDistributionPointUrlFound; break; 
                case RightsManagementFailureCode.AlreadyInProgress:
                    result=SRID.RmExceptionAlreadyInProgress; break; 
                case RightsManagementFailureCode.GroupIdentityNotSet: 
                    result=SRID.RmExceptionGroupIdentityNotSet; break;
                case RightsManagementFailureCode.RecordNotFound: 
                    result=SRID.RmExceptionRecordNotFound; break;
                case RightsManagementFailureCode.NoConnect:
                    result=SRID.RmExceptionNoConnect; break;
                case RightsManagementFailureCode.NoLicense: 
                    result=SRID.RmExceptionNoLicense; break;
                case RightsManagementFailureCode.NeedsMachineActivation: 
                    result=SRID.RmExceptionNeedsMachineActivation; break; 
                case RightsManagementFailureCode.NeedsGroupIdentityActivation:
                    result=SRID.RmExceptionNeedsGroupIdentityActivation; break; 
                case RightsManagementFailureCode.ActivationFailed:
                    result=SRID.RmExceptionActivationFailed; break;
                case RightsManagementFailureCode.Aborted:
                    result=SRID.RmExceptionAborted; break; 
                case RightsManagementFailureCode.OutOfQuota:
                    result=SRID.RmExceptionOutOfQuota; break; 
                case RightsManagementFailureCode.AuthenticationFailed: 
                    result=SRID.RmExceptionAuthenticationFailed; break;
                case RightsManagementFailureCode.ServerError: 
                    result=SRID.RmExceptionServerError; break;
                case RightsManagementFailureCode.InstallationFailed:
                    result=SRID.RmExceptionInstallationFailed; break;
                case RightsManagementFailureCode.HidCorrupted: 
                    result=SRID.RmExceptionHidCorrupted; break;
                case RightsManagementFailureCode.InvalidServerResponse: 
                    result=SRID.RmExceptionInvalidServerResponse; break; 
                case RightsManagementFailureCode.ServiceNotFound:
                    result=SRID.RmExceptionServiceNotFound; break; 
                case RightsManagementFailureCode.UseDefault:
                    result=SRID.RmExceptionUseDefault; break;
                case RightsManagementFailureCode.ServerNotFound:
                    result=SRID.RmExceptionServerNotFound; break; 
                case RightsManagementFailureCode.InvalidEmail:
                    result=SRID.RmExceptionInvalidEmail; break; 
                case RightsManagementFailureCode.ValidityTimeViolation: 
                    result=SRID.RmExceptionValidityTimeViolation; break;
                case RightsManagementFailureCode.OutdatedModule: 
                    result=SRID.RmExceptionOutdatedModule; break;
                case RightsManagementFailureCode.ServiceMoved:
                    result=SRID.RmExceptionServiceMoved; break;
                case RightsManagementFailureCode.ServiceGone: 
                    result=SRID.RmExceptionServiceGone; break;
                case RightsManagementFailureCode.AdEntryNotFound: 
                    result=SRID.RmExceptionAdEntryNotFound; break; 
                case RightsManagementFailureCode.NotAChain:
                    result=SRID.RmExceptionNotAChain; break; 
                case RightsManagementFailureCode.RequestDenied:
                    result=SRID.RmExceptionRequestDenied; break;
                case RightsManagementFailureCode.NotSet:
                    result=SRID.RmExceptionNotSet; break; 
                case RightsManagementFailureCode.MetadataNotSet:
                    result=SRID.RmExceptionMetadataNotSet; break; 
                case RightsManagementFailureCode.RevocationInfoNotSet: 
                    result=SRID.RmExceptionRevocationInfoNotSet; break;
                case RightsManagementFailureCode.InvalidTimeInfo: 
                    result=SRID.RmExceptionInvalidTimeInfo; break;
                case RightsManagementFailureCode.RightNotSet:
                    result=SRID.RmExceptionRightNotSet; break;
                case RightsManagementFailureCode.LicenseBindingToWindowsIdentityFailed: 
                    result=SRID.RmExceptionLicenseBindingToWindowsIdentityFailed; break;
                case RightsManagementFailureCode.InvalidIssuanceLicenseTemplate: 
                    result=SRID.RmExceptionInvalidIssuanceLicenseTemplate; break; 
                case RightsManagementFailureCode.InvalidKeyLength:
                    result=SRID.RmExceptionInvalidKeyLength; break; 
                case RightsManagementFailureCode.ExpiredOfficialIssuanceLicenseTemplate:
                    result=SRID.RmExceptionExpiredOfficialIssuanceLicenseTemplate; break;
                case RightsManagementFailureCode.InvalidClientLicensorCertificate:
                    result=SRID.RmExceptionInvalidClientLicensorCertificate; break; 
                case RightsManagementFailureCode.HidInvalid:
                    result=SRID.RmExceptionHidInvalid; break; 
                case RightsManagementFailureCode.EmailNotVerified: 
                    result=SRID.RmExceptionEmailNotVerified; break;
                case RightsManagementFailureCode.DebuggerDetected: 
                    result=SRID.RmExceptionDebuggerDetected; break;
                case RightsManagementFailureCode.InvalidLockboxType:
                    result=SRID.RmExceptionInvalidLockboxType; break;
                case RightsManagementFailureCode.InvalidLockboxPath: 
                    result=SRID.RmExceptionInvalidLockboxPath; break;
                case RightsManagementFailureCode.InvalidRegistryPath: 
                    result=SRID.RmExceptionInvalidRegistryPath; break; 
                case RightsManagementFailureCode.NoAesCryptoProvider:
                    result=SRID.RmExceptionNoAesCryptoProvider; break; 
                case RightsManagementFailureCode.GlobalOptionAlreadySet:
                    result=SRID.RmExceptionGlobalOptionAlreadySet; break;
                case RightsManagementFailureCode.OwnerLicenseNotFound:
                    result=SRID.RmExceptionOwnerLicenseNotFound; break; 
                default:
                    return null; 
            } 
            return SR.Get(result);
        } 
    }
}

 


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

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