// Token: 0x06001A01 RID: 6657 RVA: 0x0005DFA0 File Offset: 0x0005C1A0
protected virtual IEnumerable <RmsTemplate> AcquireRmsTemplates(OrganizationId organizationId)
{
this.HandleSimultaneousExpensiveRmsTemplateCalls(organizationId);
IEnumerable <RmsTemplate> result;
try
{
IEnumerable <RmsTemplate> enumerable;
if (RmsClientManager.IRMConfig.IsClientAccessServerEnabledForTenant(organizationId))
{
enumerable = RmsClientManager.AcquireRmsTemplates(organizationId, false);
}
else
{
enumerable = DrmEmailConstants.EmptyTemplateArray;
}
result = enumerable;
}
finally
{
if (GetComplianceConfiguration.organizationsDoingExpensiveRetrivals.Contains(organizationId))
{
lock (GetComplianceConfiguration.organizationsDoingExpensiveRetrivals)
{
GetComplianceConfiguration.organizationsDoingExpensiveRetrivals.Remove(organizationId);
}
}
}
return(result);
}
public static IEnumerable <RmsTemplate> GetRmsTemplates(OrganizationId organizationId)
{
bool flag = false;
IEnumerable <RmsTemplate> result;
try
{
if (!RmsClientManager.IRMConfig.IsInternalLicensingEnabledForTenant(organizationId))
{
RmsTemplateReaderCache.negativeCacheTimeoutForFirstOrg = ExDateTime.MinValue;
throw new AirSyncPermanentException(StatusCode.IRM_FeatureDisabled, false)
{
ErrorStringForProtocolLogger = "rtrcGrtInternalLicensingDisabled"
};
}
if (organizationId == OrganizationId.ForestWideOrgId && RmsTemplateReaderCache.negativeCacheTimeoutForFirstOrg > ExDateTime.UtcNow)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, null, "Found RMSTemplateReader for first org in negative cache");
throw new AirSyncPermanentException(StatusCode.IRM_TransientError, false)
{
ErrorStringForProtocolLogger = "rtrcGrtNegativeCacheHit"
};
}
result = RmsClientManager.AcquireRmsTemplates(organizationId, false);
}
catch (ExchangeConfigurationException ex)
{
AirSyncDiagnostics.TraceError <ExchangeConfigurationException>(ExTraceGlobals.RequestsTracer, null, "ExchangeConfigurationException encountered while acquiring RMS templates: {0}", ex);
flag = true;
throw new AirSyncPermanentException(StatusCode.IRM_TransientError, ex, false)
{
ErrorStringForProtocolLogger = "rtrcGrtExchangeConfigurationException"
};
}
catch (RightsManagementException ex2)
{
AirSyncDiagnostics.TraceError <RightsManagementException>(ExTraceGlobals.RequestsTracer, null, "RightsManagementException encountered while acquiring RMS templates: {0}", ex2);
if (ex2.FailureCode != RightsManagementFailureCode.InternalLicensingDisabled)
{
flag = true;
}
throw new AirSyncPermanentException(ex2.IsPermanent ? StatusCode.IRM_PermanentError : StatusCode.IRM_TransientError, ex2, false)
{
ErrorStringForProtocolLogger = "rtrcGrtRightsManagementException" + ex2.FailureCode.ToString()
};
}
finally
{
if (organizationId == OrganizationId.ForestWideOrgId && flag)
{
RmsTemplateReaderCache.negativeCacheTimeoutForFirstOrg = ExDateTime.UtcNow.Add(GlobalSettings.NegativeRmsTemplateCacheExpirationInterval);
}
}
return(result);
}
private IEnumerable <RmsTemplate> AcquireRmsTemplates()
{
if (this.orgId == OrganizationId.ForestWideOrgId)
{
return(RmsClientManager.AcquireRmsTemplates(this.orgId, true));
}
if (this.irmConfiguration == null || (!this.irmConfiguration.InternalLicensingEnabled && !this.displayTemplatesIfInternalLicensingDisabled))
{
return(DrmEmailConstants.EmptyTemplateArray);
}
RMSTrustedPublishingDomain rmstrustedPublishingDomain = this.FindTPD();
if (rmstrustedPublishingDomain == null)
{
return(DrmEmailConstants.EmptyTemplateArray);
}
List <RmsTemplate> list = null;
if (!MultiValuedPropertyBase.IsNullOrEmpty(rmstrustedPublishingDomain.RMSTemplates))
{
list = new List <RmsTemplate>(rmstrustedPublishingDomain.RMSTemplates.Count + 2);
using (MultiValuedProperty <string> .Enumerator enumerator = rmstrustedPublishingDomain.RMSTemplates.GetEnumerator())
{
while (enumerator.MoveNext())
{
string encodedTemplate = enumerator.Current;
RmsTemplateType type = RmsTemplateType.Archived;
string templateXrml = RMUtil.DecompressTemplate(encodedTemplate, out type);
if (this.ShouldFetch(type))
{
list.Add(RmsTemplate.CreateServerTemplateFromTemplateDefinition(templateXrml, type));
}
}
goto IL_CE;
}
}
list = new List <RmsTemplate>(2);
IL_CE:
if (this.typeToFetch != RmsTemplateType.Archived && rmstrustedPublishingDomain.Default)
{
list.Add(RmsTemplate.DoNotForward);
if (this.irmConfiguration.InternetConfidentialEnabled)
{
list.Add(RmsTemplate.InternetConfidential);
}
}
return(list);
}
private static RmsTemplate LookupRmsTemplate(Guid templateId, MailboxSession session)
{
OrganizationId organizationId = session.MailboxOwner.MailboxInfo.OrganizationId;
IrmUtils.ThrowIfInternalLicensingDisabled(organizationId);
IEnumerable <RmsTemplate> source = RmsClientManager.AcquireRmsTemplates(organizationId, false);
RmsTemplate result;
try
{
result = source.SingleOrDefault((RmsTemplate template) => template.Id.Equals(templateId));
}
catch (InvalidOperationException)
{
throw new RightsManagementPermanentException(Strings.ErrorRightsManagementDuplicateTemplateId(templateId.ToString()), null);
}
return(result);
}
public IEnumerable <RmsTemplate> GetRmsTemplates()
{
this.errorAcquiringTemplates = false;
if (this.IsInternalLicensingEnabled)
{
try
{
return(RmsClientManager.AcquireRmsTemplates(this.organizationId, false));
}
catch (ExchangeConfigurationException arg)
{
ExTraceGlobals.CoreTracer.TraceError <ExchangeConfigurationException>(0L, "ExchangeConfigurationException while loading RMS templates: {0}", arg);
this.errorAcquiringTemplates = true;
}
catch (RightsManagementException arg2)
{
ExTraceGlobals.CoreTracer.TraceError <RightsManagementException>(0L, "RightsManagementException while Loading RMS templates: {0}", arg2);
this.errorAcquiringTemplates = true;
}
}
return(RmsTemplateReader.EmptyRmsTemplateList);
}
