private string GetDescription(RmsTemplate template, CultureInfo locale) { ComplianceReader.ThrowOnNullArgument(locale, "locale"); string result = string.Empty; if (template != null) { string name = template.GetName(locale); string description = template.GetDescription(locale); if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(description)) { if (!string.IsNullOrEmpty(name)) { result = name; } else if (!string.IsNullOrEmpty(description)) { result = description; } } else { result = name + " - " + description; } } return(result); }
private void RenderCompliance(TextWriter output, object compliance) { string text = string.Empty; string text2 = string.Empty; ComplianceType complianceType = ComplianceType.Unknown; ClassificationSummary classificationSummary = compliance as ClassificationSummary; if (classificationSummary != null) { text = classificationSummary.ClassificationID.ToString(); text2 = classificationSummary.DisplayName; complianceType = ComplianceType.MessageClassification; } RmsTemplate rmsTemplate = compliance as RmsTemplate; if (rmsTemplate != null) { text = rmsTemplate.Id.ToString(); text2 = rmsTemplate.GetName(base.UserContext.UserCulture); complianceType = ComplianceType.RmsTemplate; } if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(text2)) { string additionalAttributes = " iCType=\"" + (uint)complianceType + "\""; base.RenderMenuItem(output, text2, ThemeFileId.Clear, "divCPLA" + text, text, false, additionalAttributes, null, null, null, null, false); } }
public void SetRestriction(RmsTemplate template) { this.CheckDisposed("Restriction::set"); this.EnsureIsDecoded(); this.CheckPermission(ContentRight.Export); this.rmsTemplate = template; if (this.rmsTemplate != null) { this.restrictionInfo = new RestrictionInfo(ContentRight.Owner, ExDateTime.MaxValue, string.Empty); } else { this.restrictionInfo = null; switch (base.IconIndex) { case IconIndex.MailIrm: case IconIndex.MailIrmForwarded: case IconIndex.MailIrmReplied: base.IconIndex = IconIndex.Default; break; } } this.conversationOwner = null; this.serverUseLicense = null; this.publishLicense = null; this.UpdateEffectiveRights(); }
public bool Decode(OutboundConversionOptions options, bool acquireLicense) { this.CheckDisposed("Decode"); Util.ThrowOnNullArgument(options, "options"); this.decryptionStatus = RightsManagedMessageDecryptionStatus.Success; if (this.decodedItem != null) { return(true); } if (this.InternalSession == null) { this.decryptionStatus = RightsManagedMessageDecryptionStatus.NotSupported; throw new InvalidOperationException("Decoding of in-memory messages is not supported."); } RightsManagedMessageItem.CheckSession(this.InternalSession); this.SetConversionOptions(options); using (DisposeGuard disposeGuard = default(DisposeGuard)) { try { MessageItem messageItem = ItemConversion.OpenRestrictedContent(this, this.orgId, acquireLicense, out this.licenseAcquired, out this.useLicenseValue, out this.restrictionInfo); if (messageItem == null) { ExTraceGlobals.StorageTracer.TraceError(0L, "Failed to decode protected message - no user license is present."); throw new RightsManagementPermanentException(RightsManagementFailureCode.UnknownFailure, ServerStrings.GenericFailureRMDecryption); } disposeGuard.Add <MessageItem>(messageItem); this.UpdateEffectiveRights(); this.conversationOwner = new Participant(this.restrictionInfo.ConversationOwner, this.restrictionInfo.ConversationOwner, "SMTP"); this.CheckPermission(ContentRight.View); messageItem.CoreItem.TopLevelItem = (base.CoreItem.TopLevelItem ?? base.CoreItem); this.serverUseLicense = (messageItem.TryGetProperty(MessageItemSchema.DRMServerLicense) as string); this.publishLicense = (messageItem.TryGetProperty(MessageItemSchema.DrmPublishLicense) as string); this.rmsTemplate = RmsTemplate.CreateFromPublishLicense(this.publishLicense); MsgToRpMsgConverter.CallRM(delegate { this.publishedByExternalRMS = !RmsClientManager.IsPublishedByOrganizationRMS(this.orgId, this.publishLicense); }, ServerStrings.FailedToCheckPublishLicenseOwnership(this.orgId.ToString())); this.decodedItem = messageItem; disposeGuard.Success(); } catch (RightsManagementPermanentException exception) { this.decryptionStatus = RightsManagedMessageDecryptionStatus.CreateFromException(exception); throw; } catch (RightsManagementTransientException exception2) { this.decryptionStatus = RightsManagedMessageDecryptionStatus.CreateFromException(exception2); throw; } } return(true); }
public static string TemplateNamesFromTemplateArray(string[] templateXrMLArray) { RmsUtil.ThrowIfParameterNull(templateXrMLArray, "templateXrMLArray"); List <string> list = new List <string>(); foreach (string templateXrml in templateXrMLArray) { RmsTemplate rmsTemplate = RmsTemplate.CreateServerTemplateFromTemplateDefinition(templateXrml, RmsTemplateType.Archived); list.Add(rmsTemplate.Name); } return(string.Join(", ", list.ToArray())); }
internal RmsTemplatePresentation(RmsTemplate template) : base(new SimpleProviderPropertyBag()) { if (template == null) { throw new ArgumentNullException("template"); } this.propertyBag.SetField(RmsTemplatePresentationSchema.Name, template.GetName(CultureInfo.CurrentUICulture)); this.propertyBag.SetField(RmsTemplatePresentationSchema.Description, template.GetDescription(CultureInfo.CurrentUICulture)); this.propertyBag.SetField(RmsTemplatePresentationSchema.Type, template.Type); this.propertyBag.SetField(RmsTemplatePresentationSchema.TemplateGuid, template.Id); this.propertyBag.SetField(SimpleProviderObjectSchema.Identity, new RmsTemplateIdentity(template.Id, template.Name, template.Type)); }
private bool LoadRightsManagementLicenseData(Item mailboxItem, RightsManagementLicenseData rightsManagementLicenseData) { if (!BodyConversionUtilities.IsMessageRestrictedAndDecoded(mailboxItem) && !BodyConversionUtilities.IsIRMFailedToDecode(mailboxItem)) { return(false); } if (BodyConversionUtilities.IsIRMFailedToDecode(mailboxItem)) { rightsManagementLicenseData.InitNoRightsTemplate(); return(true); } RightsManagedMessageItem rightsManagedMessageItem = mailboxItem as RightsManagedMessageItem; rightsManagementLicenseData.EditAllowed = new bool?(rightsManagedMessageItem.UsageRights.IsUsageRightGranted(ContentRight.Edit)); rightsManagementLicenseData.ReplyAllowed = new bool?(rightsManagedMessageItem.UsageRights.IsUsageRightGranted(ContentRight.Reply)); rightsManagementLicenseData.ReplyAllAllowed = new bool?(rightsManagedMessageItem.UsageRights.IsUsageRightGranted(ContentRight.ReplyAll)); rightsManagementLicenseData.ForwardAllowed = new bool?(rightsManagedMessageItem.UsageRights.IsUsageRightGranted(ContentRight.Forward)); rightsManagementLicenseData.PrintAllowed = new bool?(rightsManagedMessageItem.UsageRights.IsUsageRightGranted(ContentRight.Print)); rightsManagementLicenseData.ExtractAllowed = new bool?(rightsManagedMessageItem.UsageRights.IsUsageRightGranted(ContentRight.Extract)); rightsManagementLicenseData.ProgrammaticAccessAllowed = new bool?(rightsManagedMessageItem.UsageRights.IsUsageRightGranted(ContentRight.ObjectModel)); rightsManagementLicenseData.Owner = new bool?(rightsManagedMessageItem.UsageRights.IsUsageRightGranted(ContentRight.Owner)); if (!AirSyncUtility.IsProtectedVoicemailItem(mailboxItem)) { rightsManagementLicenseData.ExportAllowed = new bool?(rightsManagedMessageItem.UsageRights.IsUsageRightGranted(ContentRight.Export)); } else { rightsManagementLicenseData.ExportAllowed = new bool?(false); } if (rightsManagedMessageItem.UsageRights.IsUsageRightGranted(ContentRight.Forward) && (!rightsManagedMessageItem.Restriction.RequiresRepublishingWhenRecipientsChange || rightsManagedMessageItem.CanRepublish)) { rightsManagementLicenseData.ModifyRecipientsAllowed = new bool?(true); } else { rightsManagementLicenseData.ModifyRecipientsAllowed = new bool?(false); } rightsManagementLicenseData.ContentExpiryDate = new ExDateTime?(rightsManagedMessageItem.UserLicenseExpiryTime); rightsManagementLicenseData.ContentOwner = rightsManagedMessageItem.ConversationOwner.EmailAddress; RmsTemplate restriction = rightsManagedMessageItem.Restriction; if (restriction != null) { Guid id = restriction.Id; rightsManagementLicenseData.TemplateID = restriction.Id.ToString(); rightsManagementLicenseData.TemplateName = restriction.GetName(Command.CurrentCommand.MailboxSession.PreferedCulture); rightsManagementLicenseData.TemplateDescription = restriction.GetDescription(Command.CurrentCommand.MailboxSession.PreferedCulture); } return(true); }
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); }
public ComplianceType GetComplianceType(Guid guid, CultureInfo locale) { ClassificationSummary classificationSummary = this.messageClassificationReader.LookupMessageClassification(guid, locale); if (classificationSummary != null) { return(ComplianceType.MessageClassification); } RmsTemplate rmsTemplate = this.rmsTemplateReader.LookupRmsTemplate(guid); if (rmsTemplate != null) { return(ComplianceType.RmsTemplate); } return(ComplianceType.Unknown); }
internal bool Match(RmsTemplate template) { if (template == null) { return(false); } if (this.id.Equals(template.Id) || string.IsNullOrEmpty(this.name) || string.Equals(this.name, template.Name, StringComparison.OrdinalIgnoreCase)) { return(true); } foreach (CultureInfo locale in RmsTemplate.SupportedClientLanguages) { if (string.Equals(this.name, template.GetName(locale), StringComparison.OrdinalIgnoreCase)) { return(true); } } return(false); }
public override void ReadData(IConfigurationSession session) { RMSTrustedPublishingDomain[] array = session.Find <RMSTrustedPublishingDomain>(null, QueryScope.SubTree, null, null, 0); if (array == null || array.Length == 0) { return; } foreach (RMSTrustedPublishingDomain rmstrustedPublishingDomain in array) { if (rmstrustedPublishingDomain.Default && !MultiValuedPropertyBase.IsNullOrEmpty(rmstrustedPublishingDomain.RMSTemplates)) { foreach (string encodedTemplate in rmstrustedPublishingDomain.RMSTemplates) { string text = null; try { RmsTemplateType rmsTemplateType; text = RMUtil.DecompressTemplate(encodedTemplate, out rmsTemplateType); if (rmsTemplateType == RmsTemplateType.Distributed) { RmsTemplate rmsTemplate = RmsTemplate.CreateServerTemplateFromTemplateDefinition(text, rmsTemplateType); this.templates.Add(rmsTemplate.Id, rmsTemplate); this.estimatedSize += rmsTemplate.ItemSize + 16L; } } catch (FormatException arg) { RmsConfiguration.Tracer.TraceError <string, FormatException>((long)this.GetHashCode(), "Failed to read template {0}. Error {1}", text, arg); } catch (InvalidRpmsgFormatException arg2) { RmsConfiguration.Tracer.TraceError <string, InvalidRpmsgFormatException>((long)this.GetHashCode(), "Failed to read template {0}. Error {1}", text, arg2); } catch (RightsManagementException arg3) { RmsConfiguration.Tracer.TraceError <string, RightsManagementException>((long)this.GetHashCode(), "Failed to read template {0}. Error {1}", text, arg3); } } } } }
// Token: 0x06001567 RID: 5479 RVA: 0x0007DF30 File Offset: 0x0007C130 protected MessageItem GetRightsManagedReplyForward(MessageItem smartReply, SendMailBase.IrmAction irmAction, RmsTemplate rmsTemplate) { if (smartReply == null) { throw new ArgumentNullException("smartReply"); } if (irmAction != SendMailBase.IrmAction.CreateNewPublishingLicense && irmAction != SendMailBase.IrmAction.CreateNewPublishingLicenseInlineOriginalBody && irmAction != SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage) { throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Unexpected irmAction value: {0}", new object[] { irmAction })); } RightsManagedMessageItem rightsManagedMessageItem = smartReply as RightsManagedMessageItem; if (irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseInlineOriginalBody) { rightsManagedMessageItem.SetRestriction(rmsTemplate); } else if (irmAction == SendMailBase.IrmAction.CreateNewPublishingLicense || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage) { rightsManagedMessageItem = RightsManagedMessageItem.Create(smartReply, AirSyncUtility.GetOutboundConversionOptions()); rightsManagedMessageItem.SetRestriction(rmsTemplate); rightsManagedMessageItem.Sender = new Participant(base.MailboxSession.MailboxOwner); } return(rightsManagedMessageItem); }
private Stream LoadAttachmentDocument(bool isLoadingStream, out RightsManagedMessageDecryptionStatus decryptionStatus) { decryptionStatus = RightsManagedMessageDecryptionStatus.Success; StringBuilder stringBuilder = new StringBuilder(); List <AttachmentId> list = new List <AttachmentId>(); UserContext userContext = this.owaContext.UserContext; string queryStringParameter = Utilities.GetQueryStringParameter(this.owaContext.HttpContext.Request, "ewsid", false); bool flag = string.IsNullOrEmpty(queryStringParameter); OwaStoreObjectId owaStoreObjectId; string text; if (!flag) { stringBuilder.Append("service.svc/s/GetFileAttachment?id="); stringBuilder.Append(Utilities.UrlEncode(queryStringParameter)); string canary15CookieValue = Utilities.GetCanary15CookieValue(); if (canary15CookieValue != null) { stringBuilder.Append("&X-OWA-CANARY=" + canary15CookieValue); } IdHeaderInformation idHeaderInformation = ServiceIdConverter.ConvertFromConcatenatedId(queryStringParameter, BasicTypes.Attachment, list); owaStoreObjectId = OwaStoreObjectId.CreateFromMailboxItemId(idHeaderInformation.ToStoreObjectId()); text = owaStoreObjectId.ToString(); } else { text = Utilities.GetQueryStringParameter(this.owaContext.HttpContext.Request, "id"); owaStoreObjectId = OwaStoreObjectId.CreateFromString(text); stringBuilder.Append("attachment.ashx?attach=1&id="); stringBuilder.Append(Utilities.UrlEncode(text)); } Stream result; using (Item item = Utilities.GetItem <Item>(userContext, owaStoreObjectId, new PropertyDefinition[] { ItemSchema.SentRepresentingDisplayName, ItemSchema.Subject })) { if (!Utilities.IsPublic(item) && userContext.IsIrmEnabled && isLoadingStream) { item.OpenAsReadWrite(); } if (Utilities.IsIrmRestricted(item)) { if (!userContext.IsIrmEnabled || userContext.IsBasicExperience) { decryptionStatus = RightsManagedMessageDecryptionStatus.FeatureDisabled; return(null); } RightsManagedMessageItem rightsManagedMessageItem = (RightsManagedMessageItem)item; if (!rightsManagedMessageItem.CanDecode) { decryptionStatus = RightsManagedMessageDecryptionStatus.NotSupported; return(null); } try { Utilities.IrmDecryptIfRestricted(item, userContext, true); } catch (RightsManagementPermanentException exception) { decryptionStatus = RightsManagedMessageDecryptionStatus.CreateFromException(exception); return(null); } catch (RightsManagementTransientException exception2) { decryptionStatus = RightsManagedMessageDecryptionStatus.CreateFromException(exception2); return(null); } } this.messageFrom = ItemUtility.GetProperty <string>(item, ItemSchema.SentRepresentingDisplayName, string.Empty); this.messageSubject = ItemUtility.GetProperty <string>(item, ItemSchema.Subject, string.Empty); this.messageId = text; if (flag) { Utilities.FillAttachmentIdList(item, this.owaContext.HttpContext.Request, list); } using (StreamAttachment streamAttachment = Utilities.GetAttachment(item, list, userContext) as StreamAttachment) { if (streamAttachment == null) { throw new OwaInvalidRequestException("Attachment is not a stream attachment"); } this.mimeType = (streamAttachment.ContentType ?? streamAttachment.CalculatedContentType); this.fileName = ((!string.IsNullOrEmpty(streamAttachment.DisplayName)) ? streamAttachment.DisplayName : streamAttachment.FileName); this.fileSize = streamAttachment.Size; this.documentPath = this.fileName; this.documentIdStringBuilder.Append(Convert.ToBase64String(userContext.MailboxSession.MailboxOwner.MailboxInfo.GetDatabaseGuid().ToByteArray())); this.documentIdStringBuilder.Append("-"); for (int i = 0; i < list.Count; i++) { this.documentIdStringBuilder.Append(list[i].ToBase64String()); this.documentIdStringBuilder.Append("-"); if (flag) { stringBuilder.Append("&attid"); stringBuilder.Append(i.ToString(CultureInfo.InstalledUICulture)); stringBuilder.Append("="); stringBuilder.Append(Utilities.UrlEncode(list[i].ToBase64String())); } } if (flag) { stringBuilder.Append("&attcnt="); stringBuilder.Append(list.Count); } this.documentIdStringBuilder.Append(streamAttachment.LastModifiedTime.UtcTicks); this.openLink = stringBuilder.ToString(); if (isLoadingStream) { Stream contentStream = streamAttachment.GetContentStream(); MsoIpiResult msoIpiResult = MsoIpiResult.Unknown; try { msoIpiResult = ProtectorsManager.Instance.IsProtected(this.fileName, contentStream); } catch (AttachmentProtectionException exception3) { decryptionStatus = new RightsManagedMessageDecryptionStatus(RightsManagementFailureCode.CorruptData, exception3); return(null); } if (msoIpiResult == MsoIpiResult.Protected) { this.isIrmProtected = true; contentStream.Dispose(); if (!userContext.IsIrmEnabled || userContext.IsBasicExperience) { decryptionStatus = RightsManagedMessageDecryptionStatus.FeatureDisabled; result = null; } else { UseLicenseAndUsageRights useLicenseAndUsageRights; bool flag2; Stream stream; try { stream = StreamAttachment.OpenRestrictedAttachment(streamAttachment, this.owaContext.ExchangePrincipal.MailboxInfo.OrganizationId, this.owaContext.ExchangePrincipal.MailboxInfo.PrimarySmtpAddress.ToString(), this.owaContext.LogonIdentity.UserSid, this.owaContext.ExchangePrincipal.RecipientTypeDetails, out useLicenseAndUsageRights, out flag2); } catch (RightsManagementPermanentException exception4) { decryptionStatus = RightsManagedMessageDecryptionStatus.CreateFromException(exception4); return(null); } catch (RightsManagementTransientException exception5) { decryptionStatus = RightsManagedMessageDecryptionStatus.CreateFromException(exception5); return(null); } if (flag2 && ObjectClass.IsMessage(item.ClassName, false) && !Utilities.IsIrmRestricted(item)) { object obj = item.TryGetProperty(MessageItemSchema.IsDraft); if (obj is bool && !(bool)obj && !DrmClientUtils.IsCachingOfLicenseDisabled(useLicenseAndUsageRights.UseLicense)) { streamAttachment[AttachmentSchema.DRMRights] = useLicenseAndUsageRights.UsageRights; streamAttachment[AttachmentSchema.DRMExpiryTime] = useLicenseAndUsageRights.ExpiryTime; using (Stream stream2 = streamAttachment.OpenPropertyStream(AttachmentSchema.DRMServerLicenseCompressed, PropertyOpenMode.Create)) { DrmEmailCompression.CompressUseLicense(useLicenseAndUsageRights.UseLicense, stream2); } streamAttachment[AttachmentSchema.DRMPropsSignature] = useLicenseAndUsageRights.DRMPropsSignature; streamAttachment.Save(); item.Save(SaveMode.ResolveConflicts); } } string conversationOwnerFromPublishLicense = DrmClientUtils.GetConversationOwnerFromPublishLicense(useLicenseAndUsageRights.PublishingLicense); RmsTemplate rmsTemplate = RmsTemplate.CreateFromPublishLicense(useLicenseAndUsageRights.PublishingLicense); this.isPrintRestricted = !useLicenseAndUsageRights.UsageRights.IsUsageRightGranted(ContentRight.Print); this.isCopyRestricted = !useLicenseAndUsageRights.UsageRights.IsUsageRightGranted(ContentRight.Extract); SanitizingStringBuilder <OwaHtml> sanitizingStringBuilder = new SanitizingStringBuilder <OwaHtml>(); string str = string.Format(LocalizedStrings.GetNonEncoded(-500320626), rmsTemplate.Name, rmsTemplate.Description); sanitizingStringBuilder.Append(str); if (!string.IsNullOrEmpty(conversationOwnerFromPublishLicense)) { sanitizingStringBuilder.Append("<br>"); sanitizingStringBuilder.Append(string.Format(LocalizedStrings.GetNonEncoded(1670455506), conversationOwnerFromPublishLicense)); } this.irmInfobarMessage = sanitizingStringBuilder.ToSanitizedString <SanitizedHtmlString>(); result = stream; } } else { contentStream.Seek(0L, SeekOrigin.Begin); result = contentStream; } } else { result = null; } } } return(result); }
// Token: 0x06001589 RID: 5513 RVA: 0x0007F070 File Offset: 0x0007D270 internal override Command.ExecutionState ExecuteCommand() { MessageItem clientMessage = null; Item item = null; MessageItem messageItem = null; VersionedId versionedId = null; CalendarItemBase calendarItemBase = null; try { base.ValidateBody(); StoreObjectId defaultFolderId = base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Drafts); clientMessage = MessageItem.Create(base.MailboxSession, defaultFolderId); base.ParseMimeToMessage(clientMessage); clientMessage.Save(SaveMode.NoConflictResolution); clientMessage.Load(); versionedId = clientMessage.Id; clientMessage.Dispose(); clientMessage = MessageItem.Bind(base.MailboxSession, versionedId); item = base.GetSmartItem(); RmsTemplate rmsTemplate = null; bool isReplyAll = false; SendMailBase.IrmAction irmAction = base.GetIrmAction(delegate(RightsManagedMessageItem originalRightsManagedItem) { if (originalRightsManagedItem == null) { throw new ArgumentNullException("originalRightsManagedItem"); } isReplyAll = this.IsIrmReplyAll(originalRightsManagedItem, clientMessage); }, ref item, out rmsTemplate); Microsoft.Exchange.Data.Storage.BodyFormat bodyFormat = clientMessage.Body.Format; MeetingMessage meetingMessage = item as MeetingMessage; string text; if ((base.ReplaceMime || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage) && meetingMessage != null && !meetingMessage.IsDelegated() && (meetingMessage is MeetingCancellation || meetingMessage is MeetingRequest)) { text = string.Empty; } else { using (TextReader textReader = clientMessage.Body.OpenTextReader(bodyFormat)) { text = textReader.ReadToEnd(); } Body body = (irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseInlineOriginalBody || irmAction == SendMailBase.IrmAction.ReusePublishingLicenseInlineOriginalBody) ? ((RightsManagedMessageItem)item).ProtectedBody : item.Body; if (body.Format == Microsoft.Exchange.Data.Storage.BodyFormat.TextHtml) { if (bodyFormat == Microsoft.Exchange.Data.Storage.BodyFormat.TextPlain) { XmlDocument xmlDocument = new SafeXmlDocument(); XmlNode xmlNode = xmlDocument.CreateElement("PRE"); XmlAttribute xmlAttribute = xmlDocument.CreateAttribute("STYLE"); xmlAttribute.Value = "word-wrap:break-word; font-size:10.0pt; font-family:Tahoma; color:black"; xmlNode.Attributes.Append(xmlAttribute); xmlNode.InnerText = text; text = xmlNode.OuterXml; } bodyFormat = Microsoft.Exchange.Data.Storage.BodyFormat.TextHtml; } } ReplyForwardConfiguration replyForwardConfiguration = new ReplyForwardConfiguration(bodyFormat); replyForwardConfiguration.ConversionOptionsForSmime = AirSyncUtility.GetInboundConversionOptions(); replyForwardConfiguration.AddBodyPrefix(text); if (item is MessageItem) { MessageItem messageItem2 = (MessageItem)item; if (!messageItem2.IsReplyAllowed) { base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ReplyNotAllowed"); AirSyncPermanentException ex = new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.MessageReplyNotAllowed, null, false); throw ex; } if (isReplyAll) { messageItem = messageItem2.CreateReplyAll(defaultFolderId, replyForwardConfiguration); } else { messageItem = messageItem2.CreateReply(defaultFolderId, replyForwardConfiguration); } if (irmAction == SendMailBase.IrmAction.CreateNewPublishingLicense || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseInlineOriginalBody || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage) { messageItem = base.GetRightsManagedReplyForward(messageItem, irmAction, rmsTemplate); } } else if (item is CalendarItem) { CalendarItem item2 = (CalendarItem)item; calendarItemBase = base.GetCalendarItemBaseToReplyOrForward(item2); messageItem = calendarItemBase.CreateReply(defaultFolderId, replyForwardConfiguration); } if (messageItem == null) { base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ReplyFailed"); throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.MailSubmissionFailed, null, false); } base.CopyMessageContents(clientMessage, messageItem, true, (irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage) ? item : null); base.SendMessage(messageItem); } finally { if (clientMessage != null) { if (versionedId != null) { base.MailboxSession.Delete(DeleteItemFlags.HardDelete, new StoreId[] { versionedId }); } clientMessage.Dispose(); } if (item != null) { item.Dispose(); } if (messageItem != null) { messageItem.Dispose(); } if (calendarItemBase != null) { calendarItemBase.Dispose(); } } return(Command.ExecutionState.Complete); }
public static void LogAcquireRmsTemplateResult(RmsClientManagerContext context, RmsTemplate template) { if (!RmsClientManagerLog.rmsLogEnabled) { return; } if (context == null) { throw new ArgumentNullException("context"); } RmsClientManagerLog.LogEvent(RmsClientManagerLog.RmsClientManagerFeature.Template, RmsClientManagerLog.RmsClientManagerEvent.Success, context.OrgId, context.TransactionId, template.Id.ToString(), context.ContextStringForm); }
private Command.ExecutionState ForwardUsingXso(StoreObjectId smartId) { Item smartItem = base.GetSmartItem(smartId); MessageItem messageItem = null; VersionedId versionedId = null; MessageItem messageItem2 = null; CalendarItemBase calendarItemBase = null; try { StoreObjectId defaultFolderId = base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Drafts); messageItem = MessageItem.Create(base.MailboxSession, defaultFolderId); base.ParseMimeToMessage(messageItem); messageItem.Save(SaveMode.NoConflictResolution); messageItem.Load(); versionedId = messageItem.Id; messageItem.Dispose(); messageItem = MessageItem.Bind(base.MailboxSession, versionedId); RmsTemplate rmsTemplate = null; SendMailBase.IrmAction irmAction = base.GetIrmAction(delegate(RightsManagedMessageItem originalRightsManagedItem) { if (originalRightsManagedItem == null) { throw new ArgumentNullException("originalRightsManagedItem"); } if (!originalRightsManagedItem.UsageRights.IsUsageRightGranted(ContentRight.Forward)) { throw new AirSyncPermanentException(StatusCode.IRM_OperationNotPermitted, false) { ErrorStringForProtocolLogger = "sfcEOperationNotPermitted" }; } }, ref smartItem, out rmsTemplate); Microsoft.Exchange.Data.Storage.BodyFormat bodyFormat = messageItem.Body.Format; MeetingMessage meetingMessage = smartItem as MeetingMessage; string text; if ((base.ReplaceMime || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage) && meetingMessage != null && !meetingMessage.IsDelegated() && (meetingMessage is MeetingRequest || meetingMessage is MeetingCancellation)) { text = string.Empty; } else { using (TextReader textReader = messageItem.Body.OpenTextReader(bodyFormat)) { text = textReader.ReadToEnd(); } Body body = (irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseInlineOriginalBody || irmAction == SendMailBase.IrmAction.ReusePublishingLicenseInlineOriginalBody) ? ((RightsManagedMessageItem)smartItem).ProtectedBody : smartItem.Body; if (body.Format == Microsoft.Exchange.Data.Storage.BodyFormat.TextHtml) { if (bodyFormat == Microsoft.Exchange.Data.Storage.BodyFormat.TextPlain) { XmlDocument xmlDocument = new SafeXmlDocument(); XmlNode xmlNode = xmlDocument.CreateElement("PRE"); XmlAttribute xmlAttribute = xmlDocument.CreateAttribute("STYLE"); xmlAttribute.Value = "word-wrap:break-word; font-size:10.0pt; font-family:Tahoma; color:black"; xmlNode.Attributes.Append(xmlAttribute); xmlNode.InnerText = text; text = xmlNode.OuterXml; } bodyFormat = Microsoft.Exchange.Data.Storage.BodyFormat.TextHtml; } } ReplyForwardConfiguration replyForwardConfiguration = new ReplyForwardConfiguration(bodyFormat); replyForwardConfiguration.ConversionOptionsForSmime = AirSyncUtility.GetInboundConversionOptions(); replyForwardConfiguration.AddBodyPrefix(text); if (base.Version >= 120) { if (smartItem is MessageItem) { messageItem2 = ((MessageItem)smartItem).CreateForward(defaultFolderId, replyForwardConfiguration); if (irmAction == SendMailBase.IrmAction.CreateNewPublishingLicense || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseInlineOriginalBody || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage) { messageItem2 = base.GetRightsManagedReplyForward(messageItem2, irmAction, rmsTemplate); } } else if (smartItem is CalendarItem) { CalendarItem calendarItem = (CalendarItem)smartItem; calendarItemBase = base.GetCalendarItemBaseToReplyOrForward(calendarItem); messageItem2 = calendarItemBase.CreateForward(defaultFolderId, replyForwardConfiguration); if (!calendarItem.IsMeeting) { BodyConversionUtilities.CopyBody(messageItem, messageItem2); } } if (messageItem2 == null) { base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ForwardFailed"); throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.MailSubmissionFailed, null, false); } if (base.ReplaceMime || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage) { RightsManagedMessageItem rightsManagedMessageItem = messageItem2 as RightsManagedMessageItem; if (rightsManagedMessageItem != null) { rightsManagedMessageItem.ProtectedAttachmentCollection.RemoveAll(); } else { messageItem2.AttachmentCollection.RemoveAll(); } } base.CopyMessageContents(messageItem, messageItem2, false, (irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage) ? smartItem : null); base.SendMessage(messageItem2); } else if (smartItem is MessageItem) { using (ItemAttachment itemAttachment = messageItem.AttachmentCollection.AddExistingItem(smartItem)) { MessageItem messageItem3 = (MessageItem)smartItem; itemAttachment.FileName = messageItem3.Subject + itemAttachment.FileExtension; itemAttachment.Save(); } base.SendMessage(messageItem); } else if (smartItem is CalendarItem) { CalendarItem calendarItem2 = (CalendarItem)smartItem; messageItem2 = calendarItem2.CreateForward(defaultFolderId, replyForwardConfiguration); if (messageItem2 == null) { base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ForwardFailed2"); throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.MailSubmissionFailed, null, false); } if (!calendarItem2.IsMeeting) { BodyConversionUtilities.CopyBody(messageItem, messageItem2); } base.CopyMessageContents(messageItem, messageItem2, false, null); base.SendMessage(messageItem2); } } finally { if (messageItem != null) { if (versionedId != null) { base.MailboxSession.Delete(DeleteItemFlags.HardDelete, new StoreId[] { versionedId }); } messageItem.Dispose(); } if (smartItem != null) { smartItem.Dispose(); } if (messageItem2 != null) { messageItem2.Dispose(); } if (calendarItemBase != null) { calendarItemBase.Dispose(); } } return(Command.ExecutionState.Complete); }
// Token: 0x06001575 RID: 5493 RVA: 0x0007E438 File Offset: 0x0007C638 internal override Command.ExecutionState ExecuteCommand() { MessageItem messageItem = null; bool flag = false; DeleteItemFlags deletedItemFlag = DeleteItemFlags.HardDelete; try { base.ValidateBody(); StoreObjectId defaultFolderId = base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Drafts); messageItem = MessageItem.Create(base.MailboxSession, defaultFolderId); base.ParseMimeToMessage(messageItem); Guid guid; if (base.IsIrmOperation(out guid)) { RmsTemplate rmsTemplate = RmsTemplateReaderCache.LookupRmsTemplate(base.User.OrganizationId, guid); if (rmsTemplate == null) { AirSyncDiagnostics.TraceError <Guid>(ExTraceGlobals.RequestsTracer, this, "Template {0} not found in cache", guid); throw new AirSyncPermanentException(StatusCode.IRM_InvalidTemplateID, false) { ErrorStringForProtocolLogger = "smcEInvalidTemplateID" }; } messageItem = RightsManagedMessageItem.Create(messageItem, AirSyncUtility.GetOutboundConversionOptions()); RightsManagedMessageItem rightsManagedMessageItem = messageItem as RightsManagedMessageItem; rightsManagedMessageItem.SetRestriction(rmsTemplate); rightsManagedMessageItem.Sender = new Participant(base.MailboxSession.MailboxOwner); } Command.CurrentCommand.ProtocolLogger.SetValue(ProtocolLoggerData.ClassName, messageItem.ClassName); if (!GlobalSettings.OnlyOrganizersCanSendMeetingChanges || !this.IsMeetingRelatedMessage(messageItem)) { base.SendMessage(messageItem); flag = true; } else { bool flag2 = this.CanSendMessage(messageItem); if (GlobalSettings.GetGoidFromCalendarItemForMeetingResponse && base.Version < 160 && this.IsResponseMessageToSingleMeeting(messageItem)) { GlobalObjectId goidFromItem = this.GetGoidFromItem(messageItem); try { ResponseType valueOrDefault = messageItem.GetValueOrDefault <ResponseType>(MeetingResponseSchema.ResponseType); DefaultFolderType defaultFolderType = (valueOrDefault == ResponseType.Decline) ? DefaultFolderType.DeletedItems : DefaultFolderType.Calendar; List <PropertyBag> list = this.QueryRelatedCalendarItems(defaultFolderType, goidFromItem); if (list.Count == 0 && valueOrDefault == ResponseType.Decline) { list = this.QueryRelatedCalendarItems(DefaultFolderType.Calendar, goidFromItem); if (list.Count == 0) { list = this.QueryRelatedCalendarItems(DefaultFolderType.DeletedItems, goidFromItem); } } this.FindAndSetMessageGoid(list, messageItem, goidFromItem); } catch (Exception ex) { AirSyncDiagnostics.TraceError <Exception>(ExTraceGlobals.RequestsTracer, this, "GetRelatedCalendarItemGoid threw exception {0}", ex); AirSyncDiagnostics.SendInMemoryTraceWatson(ex); } } if (flag2) { base.SendMessage(messageItem); flag = true; } else { AirSyncDiagnostics.TraceDebug <Participant>(ExTraceGlobals.RequestsTracer, this, "Attempt to send meeting cancellation by attendee. Sender {0}", messageItem.Sender); messageItem.ClassName = "IPM.Note"; messageItem.Save(SaveMode.NoConflictResolution); deletedItemFlag = DeleteItemFlags.MoveToDeletedItems; Command.CurrentCommand.ProtocolLogger.SetValue(ProtocolLoggerData.SkipSend, true.ToString()); } } } finally { if (messageItem != null) { if (!flag) { base.DeleteMessage(messageItem, deletedItemFlag); } messageItem.Dispose(); } } return(Command.ExecutionState.Complete); }
private void ProcessGet() { using (this.user.Context.Tracker.Start(TimeId.RMSProcessGet)) { AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "Processing RightsManagementInformationSetting - Get"); XmlNode xmlNode = base.Response.OwnerDocument.CreateElement("Get", "Settings:"); XmlNode xmlNode2 = base.Response.OwnerDocument.CreateElement("RightsManagementTemplates", "RightsManagement:"); try { if (this.user.IrmEnabled) { List <RmsTemplate> list = new List <RmsTemplate>(RmsTemplateReaderCache.GetRmsTemplates(this.user.OrganizationId)); IComparer <RmsTemplate> comparer = new RightsManagementInformationSetting.RmsTemplateNameComparer(this.cultureInfo); list.Sort(comparer); int count = list.Count; int maxRmsTemplates = GlobalSettings.MaxRmsTemplates; if (count > maxRmsTemplates) { list.RemoveRange(maxRmsTemplates, count - maxRmsTemplates); } using (List <RmsTemplate> .Enumerator enumerator = list.GetEnumerator()) { while (enumerator.MoveNext()) { RmsTemplate rmsTemplate = enumerator.Current; AirSyncDiagnostics.TraceInfo <Guid>(ExTraceGlobals.RequestsTracer, this, "Found RMS template {0}", rmsTemplate.Id); XmlNode xmlNode3 = base.Response.OwnerDocument.CreateElement("RightsManagementTemplate", "RightsManagement:"); XmlNode xmlNode4 = base.Response.OwnerDocument.CreateElement("TemplateID", "RightsManagement:"); xmlNode4.InnerText = rmsTemplate.Id.ToString(); xmlNode3.AppendChild(xmlNode4); XmlNode xmlNode5 = base.Response.OwnerDocument.CreateElement("TemplateName", "RightsManagement:"); xmlNode5.InnerText = rmsTemplate.GetName(this.cultureInfo); xmlNode3.AppendChild(xmlNode5); XmlNode xmlNode6 = base.Response.OwnerDocument.CreateElement("TemplateDescription", "RightsManagement:"); xmlNode6.InnerText = rmsTemplate.GetDescription(this.cultureInfo); xmlNode3.AppendChild(xmlNode6); xmlNode2.AppendChild(xmlNode3); } goto IL_205; } } AirSyncDiagnostics.TraceError <string>(ExTraceGlobals.RequestsTracer, this, "IRM feature disabled for user {0}", this.user.DisplayName); this.status = StatusCode.IRM_FeatureDisabled; IL_205 :; } catch (AirSyncPermanentException ex) { AirSyncDiagnostics.TraceError <AirSyncPermanentException>(ExTraceGlobals.RequestsTracer, this, "AirSyncPermanentException encountered while processing RightsManagementInformationSetting->Get {0}", ex); if (base.ProtocolLogger != null && !string.IsNullOrEmpty(ex.ErrorStringForProtocolLogger)) { base.ProtocolLogger.SetValueIfNotSet(ProtocolLoggerData.Error, ex.ErrorStringForProtocolLogger); } this.ProcessException(ex); this.status = ex.AirSyncStatusCode; } XmlNode xmlNode7 = base.Response.OwnerDocument.CreateElement("Status", "Settings:"); XmlNode xmlNode8 = xmlNode7; int num = (int)this.status; xmlNode8.InnerText = num.ToString(CultureInfo.InvariantCulture); base.Response.AppendChild(xmlNode7); xmlNode.AppendChild(xmlNode2); base.Response.AppendChild(xmlNode); AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "Done processing RightsManagementInformationSetting - Get."); } }
protected void UpdateComplianceAction(MessageItem message) { if (message == null) { throw new ArgumentNullException("message"); } object parameter = base.GetParameter("CmpAc"); if (parameter == null) { return; } string text = (string)parameter; if (text == "0") { message[ItemSchema.IsClassified] = false; message[ItemSchema.ClassificationGuid] = string.Empty; message[ItemSchema.ClassificationDescription] = string.Empty; message[ItemSchema.Classification] = string.Empty; if (Utilities.IsIrmDecrypted(message)) { ((RightsManagedMessageItem)message).SetRestriction(null); } return; } Guid empty = Guid.Empty; ComplianceType complianceType = ComplianceType.Unknown; if (GuidHelper.TryParseGuid(text, out empty)) { complianceType = OwaContext.Current.UserContext.ComplianceReader.GetComplianceType(empty, base.UserContext.UserCulture); } switch (complianceType) { case ComplianceType.MessageClassification: { ClassificationSummary classificationSummary = base.UserContext.ComplianceReader.MessageClassificationReader.LookupMessageClassification(empty, base.UserContext.UserCulture); if (classificationSummary == null) { throw new OwaEventHandlerException("Invalid classification being set from client", LocalizedStrings.GetNonEncoded(-1799006479), OwaEventHandlerErrorCode.ComplianceLabelNotFoundError); } message[ItemSchema.IsClassified] = true; message[ItemSchema.ClassificationGuid] = classificationSummary.ClassificationID.ToString(); message[ItemSchema.ClassificationDescription] = classificationSummary.SenderDescription; message[ItemSchema.Classification] = classificationSummary.DisplayName; message[ItemSchema.ClassificationKeep] = classificationSummary.RetainClassificationEnabled; if (Utilities.IsIrmDecrypted(message)) { ((RightsManagedMessageItem)message).SetRestriction(null); return; } return; } case ComplianceType.RmsTemplate: if (Utilities.IsIrmDecrypted(message)) { RmsTemplate rmsTemplate = base.UserContext.ComplianceReader.RmsTemplateReader.LookupRmsTemplate(empty); if (rmsTemplate == null) { throw new OwaEventHandlerException("Invalid RMS template was sent from client.", LocalizedStrings.GetNonEncoded(-1799006479), OwaEventHandlerErrorCode.ComplianceLabelNotFoundError); } ((RightsManagedMessageItem)message).SetRestriction(rmsTemplate); if (message.Sender == null) { message.Sender = new Participant(base.UserContext.MailboxSession.MailboxOwner); } } message[ItemSchema.IsClassified] = false; message[ItemSchema.ClassificationGuid] = string.Empty; message[ItemSchema.ClassificationDescription] = string.Empty; message[ItemSchema.Classification] = string.Empty; return; } if (!OwaContext.Current.UserContext.ComplianceReader.RmsTemplateReader.IsInternalLicensingEnabled) { throw new OwaEventHandlerException("Unable to determine compliance type because licensing against internal RMS server has been disabled.", LocalizedStrings.GetNonEncoded(-27910813), OwaEventHandlerErrorCode.ComplianceLabelNotFoundError, true); } if (OwaContext.Current.UserContext.ComplianceReader.RmsTemplateReader.TemplateAcquisitionFailed) { throw new OwaEventHandlerException("Unable to determine compliance type because there was an error loading templates from the RMS server.", LocalizedStrings.GetNonEncoded(1084956906), OwaEventHandlerErrorCode.ComplianceLabelNotFoundError, true); } throw new OwaEventHandlerException("Invalid compliance label was sent from client.", LocalizedStrings.GetNonEncoded(-1799006479), OwaEventHandlerErrorCode.ComplianceLabelNotFoundError); }
public bool TryGetValue(Guid templateId, out RmsTemplate template) { return(this.templates.TryGetValue(templateId, out template)); }
// Token: 0x06001568 RID: 5480 RVA: 0x0007DFC4 File Offset: 0x0007C1C4 protected SendMailBase.IrmAction GetIrmAction(SendMailBase.GetIrmActionCallback irmActionDelegate, ref Item smartItem, out RmsTemplate rmsTemplate) { if (irmActionDelegate == null) { throw new ArgumentNullException("irmActionDelegate"); } if (smartItem == null) { throw new ArgumentNullException("smartItem"); } SendMailBase.IrmAction irmAction = SendMailBase.IrmAction.None; rmsTemplate = null; Guid guid; if (this.IsIrmOperation(out guid)) { RightsManagedMessageItem rightsManagedMessageItem = smartItem as RightsManagedMessageItem; if (rightsManagedMessageItem != null) { if (!rightsManagedMessageItem.IsRestricted || !rightsManagedMessageItem.CanDecode) { AirSyncDiagnostics.TraceError(ExTraceGlobals.RequestsTracer, this, "Either the original IRM message was not properly formatted or it could not be decoded"); throw new AirSyncPermanentException(StatusCode.IRM_OperationNotPermitted, false) { ErrorStringForProtocolLogger = "smbGiaOperationNotPermitted" }; } rightsManagedMessageItem.Decode(AirSyncUtility.GetOutboundConversionOptions(), true); irmActionDelegate(rightsManagedMessageItem); irmAction = SendMailBase.GetIrmActionForReplyForward(rightsManagedMessageItem.UsageRights, this.ReplaceMime, rightsManagedMessageItem.Restriction.Id == guid); AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "GetIrmActionForReplyForward: originalMessageRights={0}; originalTemplate={1}; newTemplate={2}; irmAction={3}", new object[] { rightsManagedMessageItem.UsageRights, rightsManagedMessageItem.Restriction.Id, guid, irmAction }); if (irmAction == SendMailBase.IrmAction.CreateNewPublishingLicense || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage) { smartItem.Dispose(); smartItem = this.GetSmartItem(); } } else { irmAction = SendMailBase.IrmAction.CreateNewPublishingLicense; } if (irmAction == SendMailBase.IrmAction.None) { throw new InvalidOperationException("irmAction should not be None here."); } if (irmAction != SendMailBase.IrmAction.ReusePublishingLicense && irmAction != SendMailBase.IrmAction.ReusePublishingLicenseInlineOriginalBody && guid != Guid.Empty) { rmsTemplate = RmsTemplateReaderCache.LookupRmsTemplate(base.User.OrganizationId, guid); if (rmsTemplate == null) { AirSyncDiagnostics.TraceError <Guid>(ExTraceGlobals.RequestsTracer, this, "Template {0} not found in cache", guid); throw new AirSyncPermanentException(StatusCode.IRM_InvalidTemplateID, false) { ErrorStringForProtocolLogger = "smbGiaInvalidTemplateID" }; } } } if ((irmAction == SendMailBase.IrmAction.ReusePublishingLicense && !this.ReplaceMime) || ((irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseInlineOriginalBody || irmAction == SendMailBase.IrmAction.ReusePublishingLicenseInlineOriginalBody || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage) && this.ReplaceMime)) { throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "irmAction = {0}, ReplaceMime = {1}", new object[] { irmAction, this.ReplaceMime })); } return(irmAction); }
internal static bool IsApplyingRmsTemplate(string complianceString, StoreSession session, out RmsTemplate template) { template = null; return(!string.IsNullOrEmpty(complianceString) && "0" != complianceString && IrmUtils.TryLookupRmsTemplate(complianceString, session, out template)); }
internal MsgToRpMsgConverter(MessageItem envelopeMessage, Participant conversationOwner, OrganizationId orgId, RmsTemplate restriction, OutboundConversionOptions options) { MsgToRpMsgConverter < > 4__this = this; using (DisposeGuard disposeGuard = this.Guard()) { this.options = options; this.orgId = orgId; this.charset = ConvertUtils.GetItemMimeCharset(envelopeMessage.CoreItem.PropertyBag); this.messageId = envelopeMessage.InternetMessageId; MsgToRpMsgConverter.RpMsgConversionAddressCache rpMsgConversionAddressCache = new MsgToRpMsgConverter.RpMsgConversionAddressCache(this.options); rpMsgConversionAddressCache.CopyRecipientsFromItem(envelopeMessage); rpMsgConversionAddressCache.Sender = conversationOwner; if (envelopeMessage.From != null) { rpMsgConversionAddressCache.From = envelopeMessage.From; } rpMsgConversionAddressCache.Resolve(); string senderAddress = ItemToMimeConverter.TryGetParticipantSmtpAddress(rpMsgConversionAddressCache.Sender ?? conversationOwner); if (string.IsNullOrEmpty(senderAddress)) { ExTraceGlobals.StorageTracer.TraceError <string>(0L, "Message sender must have SMTP address to protect the message: {0}", conversationOwner.DisplayName); throw new CorruptDataException(ServerStrings.CannotProtectMessageForNonSmtpSender); } List <string> recipientAddresses = new List <string>(envelopeMessage.Recipients.Count); for (int i = 0; i < envelopeMessage.Recipients.Count; i++) { string text = ItemToMimeConverter.TryGetParticipantSmtpAddress(rpMsgConversionAddressCache.GetRecipient(i) ?? envelopeMessage.Recipients[i].Participant); if (!string.IsNullOrEmpty(text)) { recipientAddresses.Add(text); } else { ExTraceGlobals.StorageTracer.TraceError <string>(0L, "Message recipient must have SMTP address to be included in the IRM message license: {0}", envelopeMessage.Recipients[i].Participant.DisplayName); } } string fromAddress = string.Empty; if (rpMsgConversionAddressCache.From != null) { fromAddress = ItemToMimeConverter.TryGetParticipantSmtpAddress(rpMsgConversionAddressCache.From); if (string.IsNullOrEmpty(fromAddress)) { ExTraceGlobals.StorageTracer.TraceError <string>(0L, "Message from participant must have SMTP address to be included in the IRM message license: {0}", rpMsgConversionAddressCache.From.DisplayName); } } this.InitTenantLicenses(); MsgToRpMsgConverter.CallRM(delegate {
private static bool TryLookupRmsTemplate(string complianceIdString, StoreSession session, out RmsTemplate template) { template = null; MailboxSession mailboxSession = session as MailboxSession; if (mailboxSession == null) { return(false); } Guid guid; if (!GuidHelper.TryParseGuid(complianceIdString, out guid) || Guid.Empty.Equals(guid)) { return(false); } Exception ex = null; try { template = IrmUtils.LookupRmsTemplate(guid, mailboxSession); } catch (RightsManagementPermanentException ex2) { ex = ex2; } catch (RightsManagementTransientException ex3) { ex = ex3; } catch (ExchangeConfigurationException ex4) { ex = ex4; } if (ex != null) { ExTraceGlobals.CommonTracer.TraceError <Exception>(0L, "Failed to lookup RMS template due to: {0}", ex); } return(null != template); }