public static LicenseIdentity GetLicenseIdentity(RmsClientManagerContext context, string recipientAddress)
{
ArgumentValidator.ThrowIfNull("context", context);
ArgumentValidator.ThrowIfNullOrEmpty("recipientAddress", recipientAddress);
ADRawEntry adrawEntry;
try
{
adrawEntry = context.ResolveRecipient(recipientAddress);
}
catch (ADTransientException innerException)
{
throw new ExchangeConfigurationException(ServerStrings.FailedToReadUserConfig(recipientAddress), innerException);
}
catch (ADOperationException innerException2)
{
throw new RightsManagementException(RightsManagementFailureCode.ADUserNotFound, ServerStrings.FailedToReadUserConfig(recipientAddress), innerException2);
}
if (adrawEntry == null)
{
throw new RightsManagementException(RightsManagementFailureCode.ADUserNotFound, ServerStrings.FailedToReadUserConfig(recipientAddress));
}
List <string> federatedEmailAddresses = RmsClientManagerUtils.GetFederatedEmailAddresses(context.OrgId, (ProxyAddressCollection)adrawEntry[ADRecipientSchema.EmailAddresses]);
if (federatedEmailAddresses.Count == 0)
{
RmsClientManager.TraceFail(null, context.SystemProbeId, "GetLicenseIdentity: User {0} doesn't have any SMTP proxy address from a domain that is federated.", new object[]
{
recipientAddress
});
throw new RightsManagementException(RightsManagementFailureCode.ADUserNotFederated, DirectoryStrings.UserHasNoSmtpProxyAddressWithFederatedDomain);
}
return(new LicenseIdentity(federatedEmailAddresses[0], federatedEmailAddresses.ToArray()));
}
public static LicenseResponse[] GetLicenseResponses(UseLicenseResult[] endUseLicenses, Uri licenseUri)
{
RmsClientManagerUtils.ThrowOnNullOrEmptyArrayArgument("endUseLicenses", endUseLicenses);
LicenseResponse[] array = new LicenseResponse[endUseLicenses.Length];
for (int i = 0; i < endUseLicenses.Length; i++)
{
UseLicenseResult useLicenseResult = endUseLicenses[i];
if (useLicenseResult.Error != null)
{
array[i] = new LicenseResponse(new RightsManagementException(RightsManagementFailureCode.OfflineRmsServerFailure, ServerStrings.FailedToAcquireUseLicense(licenseUri), useLicenseResult.Error));
}
else
{
ContentRight?usageRights;
try
{
usageRights = new ContentRight?(DrmClientUtils.GetUsageRightsFromLicense(useLicenseResult.EndUseLicense));
}
catch (RightsManagementException arg)
{
Microsoft.Exchange.Diagnostics.Components.Data.Storage.ExTraceGlobals.RightsManagementTracer.TraceError <int, RightsManagementException>(0L, "Failed to get usage rights from license for recipient index {0}. Error {1}", i, arg);
usageRights = null;
}
array[i] = new LicenseResponse(useLicenseResult.EndUseLicense, usageRights);
}
}
return(array);
}
public static List <string> GetDelegatedEmailAddressesFromB2BUseLicense(string useLicense)
{
XmlDocument firstNodeXdoc = RmsClientManagerUtils.GetFirstNodeXdoc(useLicense);
if (firstNodeXdoc == null)
{
return(null);
}
XmlNode xmlNode = firstNodeXdoc.SelectSingleNode("XrML/BODY[@type=\"LICENSE\"]/ISSUEDPRINCIPALS/PRINCIPAL/OBJECT[@type=\"Group-Identity\"]/ADDRESS[@type=\"DelegatedEmailAddress\"]/text()");
List <string> list = new List <string>();
if (RmsClientManagerUtils.ValidateDelegatedEmailAddressOrAliasNode(xmlNode))
{
list.Add(xmlNode.Value);
}
XmlNodeList xmlNodeList = firstNodeXdoc.SelectNodes("XrML/BODY[@type=\"LICENSE\"]/ISSUEDPRINCIPALS/PRINCIPAL/OBJECT[@type=\"Group-Identity\"]/ADDRESS[@type=\"email_alias\"]/text()");
foreach (object obj in xmlNodeList)
{
XmlNode xmlNode2 = (XmlNode)obj;
if (RmsClientManagerUtils.ValidateDelegatedEmailAddressOrAliasNode(xmlNode2))
{
list.Add(xmlNode2.Value);
}
}
return(list);
}
public UseLicenseAsyncResult(RmsClientManagerContext context, Uri licenseUri, XmlNode[] issuanceLicense, object callerState, AsyncCallback callerCallback) : base(context, callerState, callerCallback)
{
ArgumentValidator.ThrowIfNull("licenseUri", licenseUri);
RmsClientManagerUtils.ThrowOnNullOrEmptyArrayArgument("issuanceLicense", issuanceLicense);
this.licenseUri = licenseUri;
this.issuanceLicense = issuanceLicense;
}
public static OrganizationId OrgIdFromPublishingLicenseOrDefault(string publishingLicense, OrganizationId defaultOrgId, out Guid externalDirectoryOrgId)
{
ArgumentValidator.ThrowIfNullOrEmpty("publishingLicense", publishingLicense);
ArgumentValidator.ThrowIfNull("defaultOrgId", defaultOrgId);
externalDirectoryOrgId = Guid.Empty;
Guid guid;
if (!RmsClientManagerUtils.ExtractExternalOrgIdFromPublishingLicense(publishingLicense, out guid))
{
return(defaultOrgId);
}
Guid b;
if (!RmsClientManager.IRMConfig.GetTenantExternalDirectoryOrgId(defaultOrgId, out b))
{
return(defaultOrgId);
}
if (guid == b)
{
return(defaultOrgId);
}
OrganizationId result;
if (ADOperationResult.Success == RmsClientManagerUtils.TryGetOrganizationIdFromExternalDirectoryOrgId(guid, out result))
{
externalDirectoryOrgId = guid;
return(result);
}
return(defaultOrgId);
}
public RmsClientManagerContext(OrganizationId orgId, RmsClientManagerContext.ContextId contextId, string contextValue, IADRecipientCache recipientCache, IRmsLatencyTracker latencyTracker, string publishingLicense = null) : this(orgId, contextId, contextValue, Guid.NewGuid(), recipientCache, latencyTracker)
{
if (!string.IsNullOrEmpty(publishingLicense))
{
this.orgId = RmsClientManagerUtils.OrgIdFromPublishingLicenseOrDefault(publishingLicense, orgId, out this.externalDirectoryOrgId);
}
}
public RmsClientManagerContext(OrganizationId orgId, RmsClientManagerContext.ContextId contextId, string contextValue, string publishingLicense = null) : this(orgId, contextId, contextValue, Guid.NewGuid(), null, null)
{
if (!string.IsNullOrEmpty(publishingLicense))
{
this.orgId = RmsClientManagerUtils.OrgIdFromPublishingLicenseOrDefault(publishingLicense, orgId, out this.externalDirectoryOrgId);
}
}
public static ExDateTime GetUseLicenseExpiryTime(string license, ContentRight usageRights)
{
ArgumentValidator.ThrowIfNullOrEmpty("license", license);
XmlDocument firstNodeXdoc = RmsClientManagerUtils.GetFirstNodeXdoc(license);
if (firstNodeXdoc == null)
{
Microsoft.Exchange.Diagnostics.Components.Data.Storage.ExTraceGlobals.RightsManagementTracer.TraceDebug(0L, "Failed to parse the use license. Returning DateTime.MaxValue");
return(ExDateTime.MaxValue);
}
XmlNode xmlNode = firstNodeXdoc.SelectSingleNode("XrML/BODY[@type=\"LICENSE\"]/ISSUEDTIME/text()");
if (xmlNode == null || string.IsNullOrEmpty(xmlNode.Value))
{
Microsoft.Exchange.Diagnostics.Components.Data.Storage.ExTraceGlobals.RightsManagementTracer.TraceError(0L, "Failed to parse the use license to get the issued Time. Returning DateTime.MaxValue");
return(ExDateTime.MaxValue);
}
DateTime d;
if (!DateTime.TryParseExact(xmlNode.Value, "yyyy-MM-ddTHH:mm", CultureInfo.InvariantCulture, DateTimeStyles.None, out d))
{
Microsoft.Exchange.Diagnostics.Components.Data.Storage.ExTraceGlobals.RightsManagementTracer.TraceError <string>(0L, "Invalid IssuedTime entry {0}. Returning DateTime.MaxValue", xmlNode.Value);
return(ExDateTime.MaxValue);
}
if (usageRights.IsUsageRightGranted(ContentRight.Owner))
{
Microsoft.Exchange.Diagnostics.Components.Data.Storage.ExTraceGlobals.RightsManagementTracer.TraceDebug(0L, "User has OWNER rights - trying to get the expiry time from owner node");
XmlNode xmlNode2 = firstNodeXdoc.SelectSingleNode("XrML/BODY[@type=\"LICENSE\"]/WORK/RIGHTSGROUP[@name=\"Main-Rights\"]/RIGHTSLIST/OWNER/CONDITIONLIST/TIME/INTERVALTIME/@days");
if (xmlNode2 != null)
{
Microsoft.Exchange.Diagnostics.Components.Data.Storage.ExTraceGlobals.RightsManagementTracer.TraceDebug <string>(0L, "Found the owner node {0}", xmlNode2.Value);
int num;
if (int.TryParse(xmlNode2.Value, out num))
{
return(new ExDateTime(ExTimeZone.TimeZoneFromKind(DateTimeKind.Utc), d + TimeSpan.FromDays((double)num)));
}
}
Microsoft.Exchange.Diagnostics.Components.Data.Storage.ExTraceGlobals.RightsManagementTracer.TraceDebug(0L, "Couldn't find the OWNER node - either OWNER has no expiry or the value is not parsable");
return(ExDateTime.MaxValue);
}
if (usageRights.IsUsageRightGranted(ContentRight.View))
{
Microsoft.Exchange.Diagnostics.Components.Data.Storage.ExTraceGlobals.RightsManagementTracer.TraceDebug(0L, "User has VIEW rights - trying to get the expiry time from VIEW node");
XmlNode xmlNode3 = firstNodeXdoc.SelectSingleNode("XrML/BODY[@type=\"LICENSE\"]/WORK/RIGHTSGROUP[@name=\"Main-Rights\"]/RIGHTSLIST/VIEW/CONDITIONLIST/TIME/INTERVALTIME/@days");
if (xmlNode3 != null)
{
Microsoft.Exchange.Diagnostics.Components.Data.Storage.ExTraceGlobals.RightsManagementTracer.TraceDebug <string>(0L, "Found the view node {0}", xmlNode3.Value);
int num2;
if (int.TryParse(xmlNode3.Value, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out num2))
{
return(new ExDateTime(ExTimeZone.TimeZoneFromKind(DateTimeKind.Utc), d + TimeSpan.FromDays((double)num2)));
}
}
Microsoft.Exchange.Diagnostics.Components.Data.Storage.ExTraceGlobals.RightsManagementTracer.TraceDebug(0L, "Couldn't find the VIEW node - either VIEW rights has no expiry or the value is not parsable");
}
return(ExDateTime.MaxValue);
}
public static ChannelFactory <IWSCertificationServiceChannel> CreateCertificationChannelFactory(Uri targetUri, EndpointAddress epa, LicenseIdentity identity, OrganizationId organizationId, IRmsLatencyTracker latencyTracker)
{
CustomBinding binding = RmsClientManagerUtils.CreateCustomBinding(organizationId, 0);
ChannelFactory <IWSCertificationServiceChannel> channelFactory = new ChannelFactory <IWSCertificationServiceChannel>(binding, epa);
channelFactory.Endpoint.Behaviors.Remove(typeof(ClientCredentials));
channelFactory.Endpoint.Behaviors.Add(new SamlClientCredentials(identity, organizationId, targetUri, Offer.IPCCertificationSTS, latencyTracker));
return(channelFactory);
}
private static void AcquireServerLicensingMexCallback(ICancelableAsyncResult asyncResult)
{
RmsServerInfoManager.Tracer.TraceDebug(0L, "AcquireServerLicensingMexCallback invoked");
ArgumentValidator.ThrowIfNull("asyncResult", asyncResult);
ArgumentValidator.ThrowIfNull("asyncResult.AsyncState", asyncResult.AsyncState);
AcquireServerInfoAsyncResult acquireServerInfoAsyncResult = asyncResult.AsyncState as AcquireServerInfoAsyncResult;
if (acquireServerInfoAsyncResult == null)
{
throw new InvalidOperationException("asyncResult.AsyncState has to be type of AcquireServerInfoAsyncResult.");
}
acquireServerInfoAsyncResult.AddBreadCrumb(Constants.State.AcquireServerLicensingMexCallback);
Exception ex = null;
try
{
DownloadResult downloadResult = acquireServerInfoAsyncResult.HttpClient.EndDownload(asyncResult);
acquireServerInfoAsyncResult.LatencyTracker.EndTrackRmsLatency(RmsOperationType.AcquireServerLicensingMexData);
if (downloadResult.IsSucceeded)
{
Uri targetUriFromResponse = RmsClientManagerUtils.GetTargetUriFromResponse(downloadResult.ResponseStream);
if (targetUriFromResponse == null)
{
ex = new RightsManagementException(RightsManagementFailureCode.FailedToExtractTargetUriFromMex, ServerStrings.FailedToFindTargetUriFromMExData(acquireServerInfoAsyncResult.ServerLicensingMExUri), acquireServerInfoAsyncResult.LicenseUri.ToString());
}
else
{
acquireServerInfoAsyncResult.ServerInfo.ServerLicensingWSTargetUri = TokenTarget.Fix(targetUriFromResponse);
RmsServerInfoManager.serverInfoMap.Add(acquireServerInfoAsyncResult.ServerInfo);
}
}
else
{
RmsClientManager.TraceFail(null, acquireServerInfoAsyncResult.Context.SystemProbeId, "Failed to download data from server licensing MEx {0}. Exception is {1}", new object[]
{
acquireServerInfoAsyncResult.ServerLicensingMExUri,
downloadResult.Exception
});
ex = new RightsManagementException(RightsManagementFailureCode.FailedToDownloadMexData, ServerStrings.FailedToDownloadServerLicensingMExData(downloadResult.ResponseUri), downloadResult.Exception, acquireServerInfoAsyncResult.LicenseUri.ToString());
((RightsManagementException)ex).IsPermanent = !downloadResult.IsRetryable;
}
}
finally
{
acquireServerInfoAsyncResult.Release();
}
RmsServerInfoManager.Tracer.TraceDebug(0L, "AcquireServiceLocationCallback: Invoking find service location callbacks");
RmsServerInfoManager.outstandingFindServiceLocationCalls.InvokeCallbacks(acquireServerInfoAsyncResult.LicenseUri, ex);
}
public static LicenseeIdentity[] ConvertToLicenseeIdentities(RmsClientManagerContext context, string[] identities)
{
ArgumentValidator.ThrowIfNull("context", context);
RmsClientManagerUtils.ThrowOnNullOrEmptyArrayArgument("identities", identities);
LicenseeIdentity[] array = new LicenseeIdentity[identities.Length];
for (int i = 0; i < identities.Length; i++)
{
if (!SmtpAddress.IsValidSmtpAddress(identities[i]))
{
throw new RightsManagementException(RightsManagementFailureCode.InvalidRecipient, ServerStrings.RecipientAddressInvalid(identities[i]));
}
ADRawEntry adrawEntry;
try
{
adrawEntry = context.ResolveRecipient(identities[i]);
}
catch (ADTransientException innerException)
{
throw new ExchangeConfigurationException(ServerStrings.FailedToReadUserConfig(identities[i]), innerException);
}
catch (ADOperationException innerException2)
{
throw new RightsManagementException(RightsManagementFailureCode.ADUserNotFound, ServerStrings.FailedToReadUserConfig(identities[i]), innerException2);
}
IList <string> list = RmsClientManagerUtils.EmptyProxyList;
string text = null;
bool flag = false;
if (adrawEntry != null)
{
ProxyAddressCollection proxyAddressCollection = (ProxyAddressCollection)adrawEntry[ADRecipientSchema.EmailAddresses];
if (proxyAddressCollection != null && proxyAddressCollection.Count != 0)
{
list = new List <string>(proxyAddressCollection.Count);
foreach (ProxyAddress proxyAddress in proxyAddressCollection)
{
list.Add(proxyAddress.ValueString);
}
}
SmtpAddress smtpAddress = (SmtpAddress)adrawEntry[ADRecipientSchema.PrimarySmtpAddress];
if (smtpAddress.IsValidAddress)
{
text = smtpAddress.ToString();
}
flag = RmsClientManagerUtils.TreatRecipientAsRMSSuperuser(context.OrgId, (RecipientTypeDetails)adrawEntry[ADRecipientSchema.RecipientTypeDetails]);
}
array[i] = new LicenseeIdentity(string.IsNullOrEmpty(text) ? identities[i] : text, list, flag);
}
return(array);
}
public ExternalRmsServerInfoMap(string path, int maxCount, IMruDictionaryPerfCounters perfCounters)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException("path");
}
string uniqueFileNameForProcess = RmsClientManagerUtils.GetUniqueFileNameForProcess("ExternalRmsServerInfo_1.dat");
this.dictionary = new MruDictionary <Uri, ExternalRMSServerInfo>(maxCount, new ExternalRmsServerInfoMap.UriComparer(), perfCounters);
this.serializer = new MruDictionarySerializer <Uri, ExternalRMSServerInfo>(path, uniqueFileNameForProcess, ExternalRMSServerInfo.ColumnNames, new MruDictionarySerializerRead <Uri, ExternalRMSServerInfo>(ExternalRmsServerInfoMap.TryReadValues), new MruDictionarySerializerWrite <Uri, ExternalRMSServerInfo>(ExternalRmsServerInfoMap.TryWriteValues), perfCounters);
if (!this.serializer.TryReadFromDisk(this.dictionary))
{
ExternalRmsServerInfoMap.Tracer.TraceError <string>(0L, "External Rms Server Info Map failed to read map-file ({0}).", uniqueFileNameForProcess);
}
}
internal static bool ExtractExternalOrgIdFromPublishingLicense(string publishingLicense, out Guid externalDirectoryOrgId)
{
ArgumentValidator.ThrowIfNullOrEmpty("publishingLicense", publishingLicense);
externalDirectoryOrgId = Guid.Empty;
try
{
XmlDocument firstNodeXdoc = RmsClientManagerUtils.GetFirstNodeXdoc(publishingLicense);
if (firstNodeXdoc == null)
{
return(false);
}
XmlNodeList xmlNodeList = firstNodeXdoc.SelectNodes("/XrML/BODY/ISSUEDPRINCIPALS/PRINCIPAL");
if (xmlNodeList == null || xmlNodeList.Count == 0)
{
return(false);
}
foreach (object obj in xmlNodeList[0])
{
XmlNode xmlNode = (XmlNode)obj;
if (!(xmlNode.Name != "SECURITYLEVEL") && xmlNode.Attributes != null)
{
bool flag = false;
string text = null;
foreach (object obj2 in xmlNode.Attributes)
{
XmlAttribute xmlAttribute = (XmlAttribute)obj2;
if (xmlAttribute.Name == "name" && xmlAttribute.Value == "Tenant-ID")
{
flag = true;
}
else if (xmlAttribute.Name == "value")
{
text = xmlAttribute.Value;
}
}
if (flag && !string.IsNullOrEmpty(text))
{
return(Guid.TryParse(text, out externalDirectoryOrgId));
}
}
}
}
catch (XmlException arg)
{
Microsoft.Exchange.Diagnostics.Components.Transport.ExTraceGlobals.RightsManagementTracer.TraceError <XmlException>(0L, "Exception while extracting MSODS tenant ID from publishing license: {0}", arg);
}
return(false);
}
public static WebProxy GetLocalServerProxy(bool isEndPointExternal)
{
Uri localServerProxyAddress = RmsClientManagerUtils.GetLocalServerProxyAddress();
if (localServerProxyAddress == null)
{
Microsoft.Exchange.Diagnostics.Components.Data.Storage.ExTraceGlobals.RightsManagementTracer.TraceDebug(0L, "No proxy is configured. Using system defaults");
return(null);
}
if (isEndPointExternal)
{
Microsoft.Exchange.Diagnostics.Components.Data.Storage.ExTraceGlobals.RightsManagementTracer.TraceDebug <Uri>(0L, "InternetWeb proxy is configured {0}. Using that to connect to external endpoint", localServerProxyAddress);
return(new WebProxy(localServerProxyAddress, true));
}
Microsoft.Exchange.Diagnostics.Components.Data.Storage.ExTraceGlobals.RightsManagementTracer.TraceDebug <Uri>(0L, "InternetWeb proxy is configured {0} but the end point is internal. Connecting directly", localServerProxyAddress);
return(RmsClientManagerUtils.EmptyWebProxy);
}
private RmsClientManagerContext(OrganizationId orgId, RmsClientManagerContext.ContextId contextId, string contextValue, Guid transactionId, IADRecipientCache recipientCache, IRmsLatencyTracker latencyTracker)
{
ArgumentValidator.ThrowIfNull("orgId", orgId);
this.orgId = orgId;
this.tenantId = RmsClientManagerUtils.GetTenantGuidFromOrgId(this.orgId);
this.contextId = contextId;
this.contextValue = contextValue;
this.transactionId = transactionId;
this.recipientCache = recipientCache;
this.latencyTracker = (latencyTracker ?? NoopRmsLatencyTracker.Instance);
if (this.recipientCache != null && this.recipientCache.ADSession != null)
{
this.recipientSession = this.recipientCache.ADSession;
return;
}
this.recipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(ConsistencyMode.IgnoreInvalid, this.orgId.Equals(OrganizationId.ForestWideOrgId) ? ADSessionSettings.FromRootOrgScopeSet() : ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(orgId), 248, ".ctor", "f:\\15.00.1497\\sources\\dev\\data\\src\\storage\\rightsmanagement\\RmsClientManagerContext.cs");
}
public RmsLicenseStoreInfoMap(string path, int maxCount, IMruDictionaryPerfCounters perfCounters)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException("path");
}
this.path = path;
string uniqueFileNameForProcess = RmsClientManagerUtils.GetUniqueFileNameForProcess("RmsLicenseStoreInfoMap_2.dat");
this.dictionary = new MruDictionary <MultiValueKey, RmsLicenseStoreInfo>(maxCount, new RmsLicenseStoreInfoMap.MultiValueKeyComparer(), perfCounters);
this.dictionary.OnRemoved += this.MruDictionaryOnRemoved;
this.dictionary.OnReplaced += this.MruDictionaryOnReplaced;
this.serializer = new MruDictionarySerializer <MultiValueKey, RmsLicenseStoreInfo>(path, uniqueFileNameForProcess, RmsLicenseStoreInfo.ColumnNames, new MruDictionarySerializerRead <MultiValueKey, RmsLicenseStoreInfo>(RmsLicenseStoreInfoMap.TryReadValues), new MruDictionarySerializerWrite <MultiValueKey, RmsLicenseStoreInfo>(RmsLicenseStoreInfoMap.TryWriteValues), perfCounters);
if (!this.serializer.TryReadFromDisk(this.dictionary))
{
RmsLicenseStoreInfoMap.Tracer.TraceError <string>(0L, "Rms License Store Info Map failed to read map-file ({0}).", uniqueFileNameForProcess);
}
}
public static void Start()
{
Server localServer = null;
RmsClientManagerLog.rmsLogSchema = new LogSchema("Microsoft Exchange Server", Assembly.GetExecutingAssembly().GetName().Version.ToString(), "Rms Client Manager Log", RmsClientManagerLog.Fields);
RmsClientManagerLog.rmsLog = new Log(RmsClientManagerUtils.GetUniqueFileNameForProcess(RmsClientManagerLog.LogSuffix, true), new LogHeaderFormatter(RmsClientManagerLog.rmsLogSchema), "RmsClientManagerLog");
ADOperationResult adoperationResult = ADNotificationAdapter.TryRunADOperation(delegate()
{
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 254, "Start", "f:\\15.00.1497\\sources\\dev\\data\\src\\storage\\rightsmanagement\\RmsClientManagerLog.cs");
localServer = topologyConfigurationSession.FindLocalServer();
RmsClientManagerLog.notificationCookie = ADNotificationAdapter.RegisterChangeNotification <Server>(localServer.Id, new ADNotificationCallback(RmsClientManagerLog.HandleConfigurationChange));
});
if (!adoperationResult.Succeeded)
{
RmsClientManagerLog.Tracer.TraceError <Exception>(0L, "Failed to get the local server. Unable to load the log configuration. Error {0}", adoperationResult.Exception);
throw new ExchangeConfigurationException(ServerStrings.FailedToReadConfiguration, adoperationResult.Exception);
}
RmsClientManagerLog.Configure(localServer);
}
public static ExDateTime GetUseLicenseExpiryTime(LicenseResponse response)
{
ArgumentValidator.ThrowIfNull("response", response);
return(RmsClientManagerUtils.GetUseLicenseExpiryTime(response.License, (response.UsageRights != null) ? response.UsageRights.Value : ContentRight.None));
}
public static OrganizationId OrgIdFromPublishingLicenseOrDefault(string publishingLicense, OrganizationId defaultOrgId)
{
Guid guid;
return(RmsClientManagerUtils.OrgIdFromPublishingLicenseOrDefault(publishingLicense, defaultOrgId, out guid));
}
public FederationServerLicenseAsyncResult(RmsClientManagerContext context, Uri licenseUri, XmlNode[] issuanceLicense, LicenseIdentity[] identities, LicenseResponse[] responses, object callerState, AsyncCallback callerCallback) : base(context, licenseUri, issuanceLicense, callerState, callerCallback)
{
RmsClientManagerUtils.ThrowOnNullOrEmptyArrayArgument("identities", identities);
this.identities = identities;
this.responses = responses;
}
public static IAsyncResult BeginAcquireServerInfo(RmsClientManagerContext context, Uri licenseUri, object state, AsyncCallback callback)
{
RmsServerInfoManager.ThrowIfNotInitialized();
ArgumentValidator.ThrowIfNull("licenseUri", licenseUri);
AcquireServerInfoAsyncResult acquireServerInfoAsyncResult = new AcquireServerInfoAsyncResult(context, licenseUri, state, callback);
acquireServerInfoAsyncResult.AddBreadCrumb(Constants.State.BeginAcquireServerInfo);
ExternalRMSServerInfo externalRMSServerInfo;
if (RmsServerInfoManager.serverInfoMap.TryGet(licenseUri, out externalRMSServerInfo))
{
acquireServerInfoAsyncResult.InvokeCallback();
return(acquireServerInfoAsyncResult);
}
RmsClientManagerLog.LogUriEvent(RmsClientManagerLog.RmsClientManagerFeature.ServerInfo, RmsClientManagerLog.RmsClientManagerEvent.Acquire, context, licenseUri);
WebProxy localServerProxy;
try
{
localServerProxy = RmsClientManagerUtils.GetLocalServerProxy(true);
}
catch (ExchangeConfigurationException value)
{
acquireServerInfoAsyncResult.InvokeCallback(value);
return(acquireServerInfoAsyncResult);
}
bool flag = RmsServerInfoManager.outstandingFindServiceLocationCalls.EnqueueResult(licenseUri, acquireServerInfoAsyncResult);
if (flag)
{
acquireServerInfoAsyncResult.ServerWSManager = new ServerWSManager(licenseUri, RmsServerInfoManager.perfCounters, acquireServerInfoAsyncResult.LatencyTracker, localServerProxy, RmsClientManager.AppSettings.RmsSoapQueriesTimeout);
ServiceType[] serviceTypes = new ServiceType[]
{
ServiceType.CertificationWSService,
ServiceType.ServerLicensingWSService,
ServiceType.CertificationMexService,
ServiceType.ServerLicensingMexService
};
RmsClientManager.TracePass(null, context.SystemProbeId, "Querying the RMS server {0} for server info", new object[]
{
licenseUri
});
acquireServerInfoAsyncResult.AddBreadCrumb(Constants.State.BeginFindServiceLocationsFirstRequest);
try
{
acquireServerInfoAsyncResult.ServerWSManager.BeginFindServiceLocations(serviceTypes, RmsClientManagerUtils.WrapCallbackWithUnhandledExceptionHandlerAndUpdatePoisonContext(new AsyncCallback(RmsServerInfoManager.AcquireServiceLocationCallback)), acquireServerInfoAsyncResult);
return(acquireServerInfoAsyncResult);
}
catch (InvalidOperationException ex)
{
RmsClientManager.TraceFail(null, context.SystemProbeId, "Hit an exception during BeginFindServiceLocations {0}", new object[]
{
ex
});
acquireServerInfoAsyncResult.InvokeCallback(new RightsManagementException(RightsManagementFailureCode.FindServiceLocationFailed, ServerStrings.FailedToFindServerInfo(licenseUri), ex));
return(acquireServerInfoAsyncResult);
}
}
RmsClientManager.TracePass(null, context.SystemProbeId, "A request for server info for the license uri {0} is already pending. Enqueuing the result", new object[]
{
licenseUri
});
acquireServerInfoAsyncResult.AddBreadCrumb(Constants.State.BeginFindServiceLocationsPendingRequest);
return(acquireServerInfoAsyncResult);
}
private static void AcquireCertificationMexCallback(ICancelableAsyncResult asyncResult)
{
RmsServerInfoManager.Tracer.TraceDebug(0L, "AcquireCertificationMexCallback invoked");
ArgumentValidator.ThrowIfNull("asyncResult", asyncResult);
ArgumentValidator.ThrowIfNull("asyncResult.AsyncState", asyncResult.AsyncState);
AcquireServerInfoAsyncResult acquireServerInfoAsyncResult = asyncResult.AsyncState as AcquireServerInfoAsyncResult;
if (acquireServerInfoAsyncResult == null)
{
throw new InvalidOperationException("asyncResult.AsyncState has to be type of AcquireServerInfoAsyncResult.");
}
acquireServerInfoAsyncResult.AddBreadCrumb(Constants.State.AcquireCertificationMexCallback);
Exception ex = null;
try
{
DownloadResult downloadResult = acquireServerInfoAsyncResult.HttpClient.EndDownload(asyncResult);
acquireServerInfoAsyncResult.LatencyTracker.EndTrackRmsLatency(RmsOperationType.AcquireCertificationMexData);
if (downloadResult.IsSucceeded)
{
Uri targetUriFromResponse = RmsClientManagerUtils.GetTargetUriFromResponse(downloadResult.ResponseStream);
if (targetUriFromResponse == null)
{
ex = new RightsManagementException(RightsManagementFailureCode.FailedToExtractTargetUriFromMex, ServerStrings.FailedToFindTargetUriFromMExData(acquireServerInfoAsyncResult.CertificationMExUri), acquireServerInfoAsyncResult.LicenseUri.ToString());
}
else
{
acquireServerInfoAsyncResult.ServerInfo.CertificationWSTargetUri = TokenTarget.Fix(targetUriFromResponse);
acquireServerInfoAsyncResult.AddBreadCrumb(Constants.State.BeginDownloadServerLicensingMexData);
WebProxy localServerProxy;
try
{
localServerProxy = RmsClientManagerUtils.GetLocalServerProxy(true);
}
catch (ExchangeConfigurationException ex2)
{
ex = ex2;
return;
}
HttpSessionConfig httpSessionConfig = new HttpSessionConfig();
if (localServerProxy != null)
{
httpSessionConfig.Proxy = localServerProxy;
}
acquireServerInfoAsyncResult.LatencyTracker.BeginTrackRmsLatency(RmsOperationType.AcquireServerLicensingMexData);
acquireServerInfoAsyncResult.HttpClient.BeginDownload(acquireServerInfoAsyncResult.ServerLicensingMExUri, httpSessionConfig, RmsClientManagerUtils.WrapCancellableCallbackWithUnhandledExceptionHandlerAndUpdatePoisonContext(new CancelableAsyncCallback(RmsServerInfoManager.AcquireServerLicensingMexCallback)), acquireServerInfoAsyncResult);
}
}
else
{
RmsClientManager.TraceFail(null, acquireServerInfoAsyncResult.Context.SystemProbeId, "Failed to download data from certification MEx {0}. Exception is {1}", new object[]
{
acquireServerInfoAsyncResult.CertificationMExUri,
downloadResult.Exception
});
ex = new RightsManagementException(RightsManagementFailureCode.FailedToDownloadMexData, ServerStrings.FailedToDownloadCertificationMExData(downloadResult.ResponseUri), downloadResult.Exception, acquireServerInfoAsyncResult.LicenseUri.ToString());
((RightsManagementException)ex).IsPermanent = !downloadResult.IsRetryable;
}
}
finally
{
if (ex != null)
{
acquireServerInfoAsyncResult.Release();
RmsServerInfoManager.Tracer.TraceDebug(0L, "AcquireServiceLocationCallback: Invoking find service location callbacks");
RmsServerInfoManager.outstandingFindServiceLocationCalls.InvokeCallbacks(acquireServerInfoAsyncResult.LicenseUri, ex);
}
}
}
private static void AcquireServiceLocationCallback(IAsyncResult asyncResult)
{
RmsServerInfoManager.Tracer.TraceDebug(0L, "AcquireServiceLocationCallback invoked");
ArgumentValidator.ThrowIfNull("asyncResult", asyncResult);
ArgumentValidator.ThrowIfNull("asyncResult.AsyncState", asyncResult.AsyncState);
AcquireServerInfoAsyncResult acquireServerInfoAsyncResult = asyncResult.AsyncState as AcquireServerInfoAsyncResult;
if (acquireServerInfoAsyncResult == null)
{
throw new InvalidOperationException("asyncResult.AsyncState has to be type of AcquireServerInfoAsyncResult.");
}
acquireServerInfoAsyncResult.AddBreadCrumb(Constants.State.AcquireServiceLocationCallback);
Exception ex = null;
try
{
acquireServerInfoAsyncResult.ServiceLocationResponses = acquireServerInfoAsyncResult.ServerWSManager.EndFindServiceLocations(asyncResult);
LocalizedString value;
if (!RmsServerInfoManager.ValidateResponsesAndUpdateServerInfo(acquireServerInfoAsyncResult, out value))
{
ex = new RightsManagementException(RightsManagementFailureCode.FindServiceLocationFailed, ServerStrings.ValidationForServiceLocationResponseFailed(acquireServerInfoAsyncResult.LicenseUri, value));
}
else
{
HttpSessionConfig httpSessionConfig = new HttpSessionConfig();
WebProxy localServerProxy = RmsClientManagerUtils.GetLocalServerProxy(true);
if (localServerProxy != null)
{
httpSessionConfig.Proxy = localServerProxy;
}
acquireServerInfoAsyncResult.HttpClient = new HttpClient();
acquireServerInfoAsyncResult.AddBreadCrumb(Constants.State.BeginDownloadCertificationMexData);
acquireServerInfoAsyncResult.LatencyTracker.BeginTrackRmsLatency(RmsOperationType.AcquireCertificationMexData);
acquireServerInfoAsyncResult.HttpClient.BeginDownload(acquireServerInfoAsyncResult.CertificationMExUri, httpSessionConfig, RmsClientManagerUtils.WrapCancellableCallbackWithUnhandledExceptionHandlerAndUpdatePoisonContext(new CancelableAsyncCallback(RmsServerInfoManager.AcquireCertificationMexCallback)), acquireServerInfoAsyncResult);
}
}
catch (RightsManagementException ex2)
{
RmsClientManager.TraceFail(null, acquireServerInfoAsyncResult.Context.SystemProbeId, "Hit an exception during AcquireServiceLocationCallback {0}", new object[]
{
ex2
});
ex = ex2;
}
catch (ExchangeConfigurationException ex3)
{
RmsClientManager.TraceFail(null, acquireServerInfoAsyncResult.Context.SystemProbeId, "Hit an exception during AcquireServiceLocationCallback {0}", new object[]
{
ex3
});
ex = ex3;
}
finally
{
if (ex != null)
{
acquireServerInfoAsyncResult.Release();
RmsServerInfoManager.Tracer.TraceError(0L, "AcquireServiceLocationCallback: Invoking find service location callbacks");
RmsServerInfoManager.outstandingFindServiceLocationCalls.InvokeCallbacks(acquireServerInfoAsyncResult.LicenseUri, ex);
}
}
}
public static string GetUniqueFileNameForProcess(string fileSuffix)
{
return(RmsClientManagerUtils.GetUniqueFileNameForProcess(fileSuffix, false));
}