private MessageItem GetMessageItem(bool existingMessage)
{
MessageItem messageItem;
if (existingMessage)
{
ExTraceGlobals.MailTracer.TraceDebug((long)this.GetHashCode(), "ItemId set in the request. Existing message");
messageItem = base.GetRequestItem <MessageItem>(new PropertyDefinition[0]);
if (base.UserContext.IsIrmEnabled && !Utilities.IrmDecryptIfRestricted(messageItem, base.UserContext, true) && this.ApplyingIrmCompliance())
{
messageItem = RightsManagedMessageItem.Create(messageItem, Utilities.CreateOutboundConversionOptions(base.UserContext));
}
}
else
{
ExTraceGlobals.MailTracer.TraceDebug((long)this.GetHashCode(), "ItemId wasn't set in the request. Creating new message in the drafts folder.");
messageItem = this.CreateNewMessageItem();
messageItem[ItemSchema.ConversationIndexTracking] = true;
if (Globals.ArePerfCountersEnabled)
{
OwaSingleCounters.ItemsCreated.Increment();
}
}
return(messageItem);
}
internal static void DecodeIrmMessage(StoreSession storeSession, Item mailboxItem, bool acquireLicense)
{
RightsManagedMessageItem rightsManagedMessageItem = mailboxItem as RightsManagedMessageItem;
if (rightsManagedMessageItem == null)
{
return;
}
if (!IrmUtils.DoesSessionSupportIrm(storeSession))
{
return;
}
if (!rightsManagedMessageItem.IsRestricted)
{
return;
}
if (!rightsManagedMessageItem.CanDecode)
{
return;
}
if (rightsManagedMessageItem.IsDecoded)
{
return;
}
OutboundConversionOptions outboundConversionOptions = IrmUtils.GetOutboundConversionOptions(storeSession.MailboxOwner.MailboxInfo.OrganizationId);
rightsManagedMessageItem.TryDecode(outboundConversionOptions, acquireLicense);
}
private bool IsUsageRightRestricted(ContentRight right)
{
if (this.isIrmMessageInJunkEmailFolder)
{
if (right <= ContentRight.Forward)
{
if (right != ContentRight.Print && right != ContentRight.Forward)
{
goto IL_32;
}
}
else if (right != ContentRight.Reply && right != ContentRight.ReplyAll)
{
goto IL_32;
}
return(true);
}
IL_32:
RightsManagedMessageItem rightsManagedMessageItem = this.message as RightsManagedMessageItem;
if (rightsManagedMessageItem == null || !rightsManagedMessageItem.IsRestricted)
{
return(false);
}
if (!this.userContext.IsIrmEnabled)
{
return(false);
}
if (this.irmDecryptionStatus.Failed)
{
return(!right.IsUsageRightGranted(ContentRight.Extract) && !right.IsUsageRightGranted(ContentRight.Print));
}
return(!rightsManagedMessageItem.UsageRights.IsUsageRightGranted(right));
}
// 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);
}
internal static Body GetBody(IItem xsoItem)
{
RightsManagedMessageItem rightsManagedMessageItem = xsoItem as RightsManagedMessageItem;
if (rightsManagedMessageItem != null && rightsManagedMessageItem.IsDecoded)
{
return(rightsManagedMessageItem.ProtectedBody);
}
return(xsoItem.Body);
}
private Body GetBodyFromRightsManagedMessageItem(IItem item)
{
Body result = null;
RightsManagedMessageItem rightsManagedMessageItem = item as RightsManagedMessageItem;
if (rightsManagedMessageItem != null && rightsManagedMessageItem.IsDecoded)
{
result = rightsManagedMessageItem.ProtectedBody;
}
return(result);
}
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 MessageItem CreateNewMessageItem()
{
MessageItem result;
if (this.ApplyingIrmCompliance())
{
result = RightsManagedMessageItem.Create(base.UserContext.MailboxSession, base.UserContext.DraftsFolderId, Utilities.CreateOutboundConversionOptions(base.UserContext));
}
else
{
result = MessageItem.Create(base.UserContext.MailboxSession, base.UserContext.DraftsFolderId);
}
return(result);
}
// Token: 0x0600139D RID: 5021 RVA: 0x00070E84 File Offset: 0x0006F084
internal static bool IsMessageRestrictedAndDecoded(Item item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
RightsManagedMessageItem rightsManagedMessageItem = item as RightsManagedMessageItem;
if (rightsManagedMessageItem != null && rightsManagedMessageItem.IsRestricted && rightsManagedMessageItem.IsDecoded)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.XsoTracer, item, "The message is restricted and decoded");
return(true);
}
return(false);
}
// Token: 0x0600139E RID: 5022 RVA: 0x00070ECC File Offset: 0x0006F0CC
internal static bool IsIRMFailedToDecode(Item item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
RightsManagedMessageItem rightsManagedMessageItem = item as RightsManagedMessageItem;
if (rightsManagedMessageItem != null && rightsManagedMessageItem.DecryptionStatus.Failed && rightsManagedMessageItem.DecryptionStatus.FailureCode != RightsManagementFailureCode.InternalLicensingDisabled && rightsManagedMessageItem.DecryptionStatus.FailureCode != RightsManagementFailureCode.ExternalLicensingDisabled)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.XsoTracer, item, "The message is failed to decode");
return(true);
}
return(false);
}
private void InitializeIrmInfo(IItem item, ItemPartIrmInfo itemPartIrmInfo, out AttachmentCollection attachmentCollection)
{
attachmentCollection = item.AttachmentCollection;
RightsManagedMessageItem rightsManagedMessageItem = item as RightsManagedMessageItem;
if (rightsManagedMessageItem != null && rightsManagedMessageItem.IsRestricted)
{
if (itemPartIrmInfo.DecryptionStatus.Failed || !rightsManagedMessageItem.IsDecoded)
{
attachmentCollection = null;
return;
}
attachmentCollection = rightsManagedMessageItem.ProtectedAttachmentCollection;
itemPartIrmInfo.BodyFormat = rightsManagedMessageItem.ProtectedBody.Format;
}
}
private bool IsUsageRightRestricted(ContentRight right)
{
RightsManagedMessageItem rightsManagedMessageItem = this.message as RightsManagedMessageItem;
if (rightsManagedMessageItem == null || !rightsManagedMessageItem.IsRestricted)
{
return(false);
}
if (!base.OwaContext.UserContext.IsIrmEnabled)
{
return(false);
}
if (this.irmDecryptionStatus.Failed)
{
return(!right.IsUsageRightGranted(ContentRight.Extract) && !right.IsUsageRightGranted(ContentRight.Print));
}
return(!rightsManagedMessageItem.UsageRights.IsUsageRightGranted(right));
}
private void ImportMessageMime(MessageItem item)
{
this.ClearMessagePropertiesForMimeImport(item);
InboundConversionOptions options = Utilities.CreateInboundConversionOptions(base.UserContext);
using (MemoryStream memoryStream = new MemoryStream(Encoding.ASCII.GetBytes((string)base.GetParameter("MimeBlob"))))
{
ItemConversion.ConvertAnyMimeToItem(item, memoryStream, options);
}
if (Utilities.IsIrmDecrypted(item))
{
RightsManagedMessageItem rightsManagedMessageItem = (RightsManagedMessageItem)item;
rightsManagedMessageItem.SetProtectedData(item.Body, item.AttachmentCollection);
rightsManagedMessageItem.SetDefaultEnvelopeBody(null);
}
item.From = null;
item.Sender = null;
base.UpdateComplianceAction(item);
}
// Token: 0x060022D1 RID: 8913 RVA: 0x000C7398 File Offset: 0x000C5598
public static void AddIrmInformation(Infobar infobar, MessageItem item, bool isPreviewForm, bool addConversationOwner, bool addRemoveLink, bool addAttachDisclaimer)
{
if (infobar == null)
{
throw new ArgumentNullException("infobar");
}
if (item == null)
{
throw new ArgumentNullException("item");
}
if (addAttachDisclaimer)
{
infobar.AddMessage(SanitizedHtmlString.FromStringId(-914838464), InfobarMessageType.Informational);
}
if (!Utilities.IsIrmRestrictedAndDecrypted(item))
{
return;
}
RightsManagedMessageItem rightsManagedMessageItem = (RightsManagedMessageItem)item;
SanitizingStringBuilder <OwaHtml> sanitizingStringBuilder = new SanitizingStringBuilder <OwaHtml>();
string str = string.Format(LocalizedStrings.GetNonEncoded(-500320626), rightsManagedMessageItem.Restriction.Name, rightsManagedMessageItem.Restriction.Description);
sanitizingStringBuilder.Append(str);
if (addRemoveLink)
{
sanitizingStringBuilder.Append(" <a id=\"aIbRR\" href=# ");
sanitizingStringBuilder.AppendFormat("_sIT=\"IPM.Note\" _sAct=\"{0}\" _fRR=1", new object[]
{
isPreviewForm ? "Preview" : string.Empty
});
sanitizingStringBuilder.Append(">");
sanitizingStringBuilder.Append(LocalizedStrings.GetNonEncoded(540836651));
sanitizingStringBuilder.Append("</a>");
}
if (addConversationOwner && !isPreviewForm && rightsManagedMessageItem.ConversationOwner != null && !string.IsNullOrEmpty(rightsManagedMessageItem.ConversationOwner.EmailAddress))
{
string str2 = string.Format(LocalizedStrings.GetNonEncoded(1670455506), rightsManagedMessageItem.ConversationOwner.EmailAddress);
sanitizingStringBuilder.Append("<br>");
sanitizingStringBuilder.Append(str2);
}
infobar.AddMessage(sanitizingStringBuilder.ToSanitizedString <SanitizedHtmlString>(), InfobarMessageType.Informational, "divCmplIB");
}
public void GetAttachmentExtension()
{
ExTraceGlobals.MailCallTracer.TraceDebug((long)this.GetHashCode(), "ReadVoiceMessageEventHandler.GetAttachmentExtension");
OwaStoreObjectId owaStoreObjectId = (OwaStoreObjectId)base.GetParameter("Id");
Item item = Utilities.GetItem <Item>(base.UserContext, owaStoreObjectId, new PropertyDefinition[0]);
Exception ex = null;
RightsManagedMessageItem rightsManagedMessageItem = item as RightsManagedMessageItem;
if (rightsManagedMessageItem != null && rightsManagedMessageItem.IsRestricted && base.UserContext.IsIrmEnabled)
{
try
{
rightsManagedMessageItem.Decode(Utilities.CreateOutboundConversionOptions(base.UserContext), true);
}
catch (RightsManagementPermanentException ex2)
{
ex = ex2;
}
catch (RightsManagementTransientException ex3)
{
ex = ex3;
}
}
if (ex != null)
{
throw new OwaEventHandlerException(LocalizedStrings.GetNonEncoded(756278106), LocalizedStrings.GetNonEncoded(-229902107), ex);
}
Attachment latestVoiceMailAttachment = Utilities.GetLatestVoiceMailAttachment(item, base.UserContext);
if (latestVoiceMailAttachment != null)
{
string text = latestVoiceMailAttachment.FileExtension;
if (text == null)
{
text = string.Empty;
}
Utilities.HtmlEncode(text, this.Writer);
return;
}
throw new OwaEventHandlerException(LocalizedStrings.GetNonEncoded(756278106), LocalizedStrings.GetNonEncoded(-229902107));
}
private ItemPartIrmInfo GetItemPartIrmInfo(IItem item)
{
RightsManagedMessageItem rightsManagedMessageItem = item as RightsManagedMessageItem;
if (rightsManagedMessageItem == null || !rightsManagedMessageItem.IsRestricted)
{
return(ItemPartIrmInfo.NotRestricted);
}
ItemPartIrmInfo result = null;
if (!this.canOpenIrmMessage || !rightsManagedMessageItem.CanDecode)
{
if (!this.canOpenIrmMessage)
{
result = ItemPartIrmInfo.CreateForIrmDisabled();
}
else if (!rightsManagedMessageItem.CanDecode)
{
result = ItemPartIrmInfo.CreateForUnsupportedScenario();
}
}
else
{
try
{
OutboundConversionOptions options = new OutboundConversionOptions(item.Session.GetADRecipientSession(true, ConsistencyMode.IgnoreInvalid), string.Empty);
rightsManagedMessageItem.Decode(options, true);
result = ItemPartIrmInfo.Create(rightsManagedMessageItem.UsageRights, rightsManagedMessageItem.Restriction.Name, rightsManagedMessageItem.Restriction.Description, rightsManagedMessageItem.ConversationOwner.EmailAddress, rightsManagedMessageItem.UserLicenseExpiryTime, rightsManagedMessageItem.Restriction.RequiresRepublishingWhenRecipientsChange, rightsManagedMessageItem.CanRepublish);
}
catch (RightsManagementPermanentException exception)
{
result = ItemPartIrmInfo.CreateForDecryptionFailure(exception);
}
catch (RightsManagementTransientException exception2)
{
result = ItemPartIrmInfo.CreateForDecryptionFailure(exception2);
}
}
return(result);
}
public void IrmDecryptIfRestricted()
{
if (!Utilities.IsIrmRestricted(this.message))
{
return;
}
RightsManagedMessageItem rightsManagedMessageItem = (RightsManagedMessageItem)this.message;
if (!this.userContext.IsIrmEnabled)
{
this.irmDecryptionStatus = RightsManagedMessageDecryptionStatus.FeatureDisabled;
return;
}
if (!rightsManagedMessageItem.CanDecode)
{
this.irmDecryptionStatus = RightsManagedMessageDecryptionStatus.NotSupported;
return;
}
try
{
Utilities.IrmDecryptIfRestricted(this.message, this.userContext, !this.isPreviewForm);
}
catch (MissingRightsManagementLicenseException ex)
{
this.irmDecryptionStatus = RightsManagedMessageDecryptionStatus.CreateFromException(ex);
if (!Utilities.IsPrefetchRequest(OwaContext.Current) && !this.isEmbeddedItem && ex.MessageStoreId != null && !string.IsNullOrEmpty(ex.PublishLicense))
{
OwaStoreObjectId messageId = OwaStoreObjectId.CreateFromItemId(ex.MessageStoreId, null, ex.MessageInArchive ? OwaStoreObjectIdType.ArchiveMailboxObject : OwaStoreObjectIdType.MailBoxObject, ex.MailboxOwnerLegacyDN);
this.userContext.AsyncAcquireIrmLicenses(messageId, ex.PublishLicense, ex.RequestCorrelator);
}
}
catch (RightsManagementPermanentException exception)
{
this.irmDecryptionStatus = RightsManagedMessageDecryptionStatus.CreateFromException(exception);
}
catch (RightsManagementTransientException exception2)
{
this.irmDecryptionStatus = RightsManagedMessageDecryptionStatus.CreateFromException(exception2);
}
}
private bool IrmDecryptIfRestricted(Item item, UserContext userContext)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
if (userContext == null)
{
throw new ArgumentNullException("userContext");
}
RightsManagedMessageItem rightsManagedMessageItem = item as RightsManagedMessageItem;
if (rightsManagedMessageItem != null && rightsManagedMessageItem.IsRestricted)
{
if (!rightsManagedMessageItem.IsDecoded)
{
rightsManagedMessageItem.Decode(this.CreateOutboundConversionOptions(userContext), true);
}
return(true);
}
return(false);
}
private void IrmDecryptIfRestricted()
{
if (!Utilities.IsIrmRestricted(this.message))
{
return;
}
RightsManagedMessageItem rightsManagedMessageItem = (RightsManagedMessageItem)this.message;
if (!base.UserContext.IsIrmEnabled)
{
this.irmDecryptionStatus = RightsManagedMessageDecryptionStatus.FeatureDisabled;
return;
}
if (!rightsManagedMessageItem.CanDecode)
{
this.irmDecryptionStatus = RightsManagedMessageDecryptionStatus.NotSupported;
return;
}
try
{
if (Utilities.IrmDecryptIfRestricted(this.message, base.UserContext, true))
{
RightsManagedMessageItem rightsManagedMessageItem2 = (RightsManagedMessageItem)this.message;
if (!rightsManagedMessageItem2.UsageRights.IsUsageRightGranted(ContentRight.Print))
{
this.irmDecryptionStatus = new RightsManagedMessageDecryptionStatus(RightsManagementFailureCode.UserRightNotGranted, null);
}
}
}
catch (RightsManagementPermanentException exception)
{
this.irmDecryptionStatus = RightsManagedMessageDecryptionStatus.CreateFromException(exception);
}
catch (RightsManagementTransientException exception2)
{
this.irmDecryptionStatus = RightsManagedMessageDecryptionStatus.CreateFromException(exception2);
}
}
public void GetComplianceContextMenu()
{
StoreObjectId storeObjectId = base.GetParameter("id") as StoreObjectId;
string id = "0";
if (storeObjectId != null)
{
using (Item item = Utilities.GetItem <Item>(base.UserContext, storeObjectId, ComplianceEventHandler.prefetchProperties))
{
if (Utilities.IrmDecryptIfRestricted(item, base.UserContext, true))
{
RightsManagedMessageItem rightsManagedMessageItem = (RightsManagedMessageItem)item;
id = "1";
if (rightsManagedMessageItem.Restriction != null && base.UserContext.ComplianceReader.RmsTemplateReader.LookupRmsTemplate(rightsManagedMessageItem.Restriction.Id) != null)
{
id = rightsManagedMessageItem.Restriction.Id.ToString();
}
}
else
{
bool property = ItemUtility.GetProperty <bool>(item, ItemSchema.IsClassified, false);
if (property)
{
string property2 = ItemUtility.GetProperty <string>(item, ItemSchema.ClassificationGuid, string.Empty);
id = "1";
Guid empty = Guid.Empty;
if (GuidHelper.TryParseGuid(property2, out empty) && base.UserContext.ComplianceReader.MessageClassificationReader.LookupMessageClassification(empty, base.UserContext.UserCulture) != null)
{
id = empty.ToString();
}
}
}
}
}
ComplianceContextMenu complianceContextMenu = new ComplianceContextMenu(base.UserContext, id);
complianceContextMenu.Render(this.Writer);
}
// Token: 0x0600144F RID: 5199 RVA: 0x00075120 File Offset: 0x00073320
private MessageItem CreateIrmErrorMessage()
{
RightsManagedMessageItem rightsManagedMessageItem = ((Item)base.XsoItem) as RightsManagedMessageItem;
if (rightsManagedMessageItem == null)
{
return(null);
}
bool flag = false;
MessageItem messageItem = MessageItem.CreateInMemory(StoreObjectSchema.ContentConversionProperties);
if (messageItem == null)
{
AirSyncDiagnostics.TraceError(ExTraceGlobals.XsoTracer, null, "Failed to create in memory message item");
return(null);
}
try
{
Item.CopyItemContent(rightsManagedMessageItem, messageItem);
using (TextWriter textWriter = messageItem.Body.OpenTextWriter(Microsoft.Exchange.Data.Storage.BodyFormat.TextPlain))
{
RightsManagementFailureCode failureCode = rightsManagedMessageItem.DecryptionStatus.FailureCode;
if (failureCode > RightsManagementFailureCode.PreLicenseAcquisitionFailed)
{
switch (failureCode)
{
case RightsManagementFailureCode.FailedToExtractTargetUriFromMex:
case RightsManagementFailureCode.FailedToDownloadMexData:
textWriter.Write(Strings.IRMReachNotConfiguredBodyText.ToString(rightsManagedMessageItem.Session.PreferedCulture));
goto IL_1F7;
case RightsManagementFailureCode.GetServerInfoFailed:
goto IL_1AF;
case RightsManagementFailureCode.InternalLicensingDisabled:
case RightsManagementFailureCode.ExternalLicensingDisabled:
break;
default:
switch (failureCode)
{
case RightsManagementFailureCode.ServerRightNotGranted:
textWriter.Write(Strings.IRMServerNotConfiguredBodyText.ToString(rightsManagedMessageItem.Session.PreferedCulture));
goto IL_1F7;
case RightsManagementFailureCode.InvalidLicensee:
goto IL_149;
case RightsManagementFailureCode.FeatureDisabled:
break;
case RightsManagementFailureCode.NotSupported:
case RightsManagementFailureCode.MissingLicense:
case RightsManagementFailureCode.InvalidLicensingLocation:
goto IL_1AF;
case RightsManagementFailureCode.CorruptData:
textWriter.Write(Strings.IRMCorruptProtectedMessageBodyText.ToString(rightsManagedMessageItem.Session.PreferedCulture));
goto IL_1F7;
case RightsManagementFailureCode.ExpiredLicense:
textWriter.Write(Strings.IRMLicenseExpiredBodyText.ToString(rightsManagedMessageItem.Session.PreferedCulture));
goto IL_1F7;
default:
goto IL_1AF;
}
break;
}
flag = true;
goto IL_1F7;
}
if (failureCode == RightsManagementFailureCode.UserRightNotGranted)
{
textWriter.Write(Strings.IRMNoViewRightsBodyText.ToString(rightsManagedMessageItem.Session.PreferedCulture));
goto IL_1F7;
}
if (failureCode != RightsManagementFailureCode.PreLicenseAcquisitionFailed)
{
goto IL_1AF;
}
IL_149:
textWriter.Write(Strings.IRMPreLicensingFailureBodyText.ToString(rightsManagedMessageItem.Session.PreferedCulture));
goto IL_1F7;
IL_1AF:
AirSyncDiagnostics.TraceError <string>(ExTraceGlobals.XsoTracer, null, "IRM decryption status {0}", rightsManagedMessageItem.DecryptionStatus.FailureCode.ToString());
textWriter.Write(Strings.IRMServerNotAvailableBodyText.ToString(rightsManagedMessageItem.Session.PreferedCulture));
IL_1F7 :;
}
}
catch (Exception)
{
if (messageItem != null)
{
flag = true;
}
throw;
}
finally
{
if (flag)
{
messageItem.Dispose();
messageItem = null;
}
}
return(messageItem);
}
// Token: 0x0600158B RID: 5515 RVA: 0x0007F458 File Offset: 0x0007D658
private bool IsIrmReplyAll(RightsManagedMessageItem originalMessage, MessageItem newMessage)
{
if (originalMessage == null)
{
throw new ArgumentNullException("originalMessage");
}
if (newMessage == null)
{
throw new ArgumentNullException("newMessage");
}
bool flag = true;
Participant participant = new Participant(base.User.ExchangePrincipal);
IList <Participant> list = new List <Participant>(originalMessage.ReplyTo);
list.Add(originalMessage.Sender);
list.Add(originalMessage.From);
foreach (Recipient recipient in newMessage.Recipients)
{
if (!Participant.HasSameEmail(recipient.Participant, participant, true) && !SmartReplyCommand.IsPresent(recipient.Participant, list))
{
flag = false;
break;
}
}
bool flag2 = !flag;
if (flag2)
{
foreach (Recipient recipient2 in originalMessage.Recipients)
{
if (!Participant.HasSameEmail(recipient2.Participant, participant, true) && !SmartReplyCommand.IsPresent(recipient2.Participant, list) && !newMessage.Recipients.Contains(recipient2.Participant, true))
{
flag2 = false;
break;
}
}
}
if (flag2)
{
foreach (Recipient recipient3 in newMessage.Recipients)
{
if (!Participant.HasSameEmail(recipient3.Participant, participant, true) && !SmartReplyCommand.IsPresent(recipient3.Participant, list) && !originalMessage.Recipients.Contains(recipient3.Participant, true))
{
flag2 = false;
break;
}
}
}
if (flag2 && !SmartReplyCommand.IsPresent(participant, list))
{
bool flag3 = false;
foreach (Participant participant2 in list)
{
if (newMessage.Recipients.Contains(participant2, true))
{
flag3 = true;
break;
}
}
if (!flag3)
{
flag2 = false;
}
}
bool flag4 = originalMessage.UsageRights.IsUsageRightGranted(ContentRight.Reply);
bool flag5 = originalMessage.UsageRights.IsUsageRightGranted(ContentRight.ReplyAll);
bool flag6 = originalMessage.UsageRights.IsUsageRightGranted(ContentRight.Forward);
if (flag6 || (flag4 && flag5 && (flag || flag2)) || (flag4 && !flag5 && flag && !flag2) || (!flag4 && flag5 && !flag && flag2))
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "IsIrmReplyAll: isReplyAllowed={0}; isReplyAllAllowed={1}; isForwardAllowed={2}; isReplyAll={3}", new object[]
{
flag4,
flag5,
flag6,
flag2
});
if ((flag2 && flag5) || (!flag2 && flag4))
{
return(flag2);
}
}
throw new AirSyncPermanentException(StatusCode.IRM_OperationNotPermitted, false)
{
ErrorStringForProtocolLogger = "srcIiraOperationNotPermitted"
};
}
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);
}
// Token: 0x06000C4C RID: 3148 RVA: 0x00040FE8 File Offset: 0x0003F1E8
private void IrmRemoveRestriction(Item item)
{
if (!Command.CurrentCommand.Context.User.IrmEnabled || !Command.CurrentCommand.Context.Request.IsSecureConnection)
{
AirSyncDiagnostics.TraceError <string, bool, bool>(ExTraceGlobals.RequestsTracer, null, "User {0} is not IrmEnabled or the client access server is not IrmEnabled or request received over non SSL. IrmEnabled: {1}, SSLConnection: {2}.", Command.CurrentCommand.Context.User.DisplayName, Command.CurrentCommand.Context.User.IrmEnabled, Command.CurrentCommand.Context.Request.IsSecureConnection);
throw new AirSyncPermanentException(StatusCode.IRM_FeatureDisabled, false)
{
ErrorStringForProtocolLogger = "RemoveRestrictionFeatureDisabled"
};
}
if (AirSyncUtility.IsProtectedVoicemailItem(item))
{
AirSyncDiagnostics.TraceError <string>(ExTraceGlobals.RequestsTracer, null, "User {0} called remove restrictions on protected voice mail - not supported", Command.CurrentCommand.Context.User.DisplayName);
throw new AirSyncPermanentException(StatusCode.IRM_OperationNotPermitted, false)
{
ErrorStringForProtocolLogger = "RemoveRestrictionOnProtectedVoicemail"
};
}
RightsManagedMessageItem rightsManagedMessageItem = item as RightsManagedMessageItem;
if (rightsManagedMessageItem == null)
{
AirSyncDiagnostics.TraceError <string>(ExTraceGlobals.RequestsTracer, null, "User {0} called remove restrictions on non IRM message", Command.CurrentCommand.Context.User.DisplayName);
throw new AirSyncPermanentException(StatusCode.IRM_OperationNotPermitted, false)
{
ErrorStringForProtocolLogger = "RemoveRestrictionOnNonIRMMessage"
};
}
rightsManagedMessageItem.OpenAsReadWrite();
RightsManagedMessageDecryptionStatus rightsManagedMessageDecryptionStatus = RightsManagedMessageDecryptionStatus.Success;
try
{
rightsManagedMessageItem.Decode(AirSyncUtility.GetOutboundConversionOptions(), true);
}
catch (RightsManagementPermanentException exception)
{
rightsManagedMessageDecryptionStatus = RightsManagedMessageDecryptionStatus.CreateFromException(exception);
}
catch (RightsManagementTransientException exception2)
{
rightsManagedMessageDecryptionStatus = RightsManagedMessageDecryptionStatus.CreateFromException(exception2);
}
if (rightsManagedMessageDecryptionStatus.Failed)
{
AirSyncDiagnostics.TraceError <string>(ExTraceGlobals.RequestsTracer, null, "Failed to decode item : {0}", rightsManagedMessageDecryptionStatus.FailureCode.ToString());
throw new AirSyncPermanentException(StatusCode.IRM_PermanentError, rightsManagedMessageDecryptionStatus.Exception, false)
{
ErrorStringForProtocolLogger = "RemoveRestrictionDecodeFailed"
};
}
try
{
rightsManagedMessageItem.SetRestriction(null);
}
catch (RightsManagementPermanentException ex)
{
if (ex.FailureCode == RightsManagementFailureCode.UserRightNotGranted)
{
AirSyncDiagnostics.TraceError <string>(ExTraceGlobals.RequestsTracer, null, "Failed to remove restrictions on item : {0}", ex.ToString());
throw new AirSyncPermanentException(StatusCode.IRM_OperationNotPermitted, ex, false)
{
ErrorStringForProtocolLogger = "RemoveRestrictionRightNotGranted"
};
}
throw;
}
ConflictResolutionResult conflictResolutionResult = rightsManagedMessageItem.Save(SaveMode.ResolveConflicts);
if (conflictResolutionResult.SaveStatus == SaveResult.IrresolvableConflict)
{
AirSyncDiagnostics.TraceError(ExTraceGlobals.RequestsTracer, null, "Failed to remove restrictions on item because of conflicts");
throw new AirSyncPermanentException(StatusCode.IRM_PermanentError, false)
{
ErrorStringForProtocolLogger = "RemoveRestrictionConflict"
};
}
item.Load();
}
internal static bool IsProtectedVoicemailItem(RightsManagedMessageItem item)
{
string valueOrDefault = item.GetValueOrDefault <string>(StoreObjectSchema.ItemClass);
return(valueOrDefault.StartsWith("IPM.Note.RPMSG.Microsoft.Voicemail", StringComparison.OrdinalIgnoreCase));
}
public static bool IsIrmRestricted(Item item)
{
RightsManagedMessageItem rightsManagedMessageItem = item as RightsManagedMessageItem;
return(rightsManagedMessageItem != null && rightsManagedMessageItem.IsRestricted);
}
private void ProcessMessageRequest(MessageAction action)
{
bool flag = false;
MessageItem messageItem = null;
bool flag2 = base.IsParameterSet("Id");
bool flag3 = false;
RecipientInfoAC[] array = (RecipientInfoAC[])base.GetParameter("Recips");
if (array != null && array.Length != 0)
{
AutoCompleteCache.UpdateAutoCompleteCacheFromRecipientInfoList(array, base.OwaContext.UserContext);
}
try
{
messageItem = this.GetMessageItem(flag2);
base.SaveHideMailTipsByDefault();
switch (action)
{
case MessageAction.Send:
case MessageAction.Save:
{
StoreObjectType storeObjectType = StoreObjectType.Message;
if (ObjectClass.IsMeetingRequest(messageItem.ClassName) || ObjectClass.IsMeetingCancellation(messageItem.ClassName) || ObjectClass.IsMeetingResponse(messageItem.ClassName))
{
storeObjectType = StoreObjectType.MeetingMessage;
}
flag = base.UpdateMessage(messageItem, storeObjectType);
break;
}
case MessageAction.SendMime:
case MessageAction.SaveMime:
this.ImportMessageMime(messageItem);
flag3 = (base.IsParameterSet("SavToSnt") && !(bool)base.GetParameter("SavToSnt"));
if (action == MessageAction.SendMime && base.IsParameterSet("Encrypted") && (bool)base.GetParameter("Encrypted") && base.IsParameterSet("DavSubmitData"))
{
messageItem[MessageItemSchema.DavSubmitData] = (string)base.GetParameter("DavSubmitData");
}
else
{
base.UpdateRecipients(messageItem);
}
break;
}
if (action == MessageAction.Save || action == MessageAction.SaveMime)
{
ExTraceGlobals.MailTracer.TraceDebug((long)this.GetHashCode(), "Saving message");
Utilities.SaveItem(messageItem, flag2);
base.WriteIdAndChangeKey(messageItem, flag2);
if (!flag2 && ExTraceGlobals.MailDataTracer.IsTraceEnabled(TraceType.DebugTrace))
{
ExTraceGlobals.MailDataTracer.TraceDebug <string>((long)this.GetHashCode(), "EditMessageEventHandler.ProcessMessageRequest - New message ID is '{0}'", messageItem.Id.ObjectId.ToBase64String());
}
}
else if (action == MessageAction.Send || action == MessageAction.SendMime)
{
if (flag)
{
throw new OwaEventHandlerException("Unresolved recipients", LocalizedStrings.GetNonEncoded(2063734279));
}
RightsManagedMessageItem rightsManagedMessageItem = messageItem as RightsManagedMessageItem;
bool flag4 = rightsManagedMessageItem != null && rightsManagedMessageItem.Restriction != null;
if (messageItem.Recipients.Count == 0 && (action == MessageAction.Send || action != MessageAction.SendMime || !base.IsParameterSet("Encrypted") || !(bool)base.GetParameter("Encrypted")))
{
throw new OwaEventHandlerException("No recipients", LocalizedStrings.GetNonEncoded(1878192149));
}
if (Utilities.RecipientsOnlyHaveEmptyPDL <Recipient>(base.UserContext, messageItem.Recipients))
{
base.RenderPartialFailure(1389137820);
}
else
{
ExTraceGlobals.MailTracer.TraceDebug((long)this.GetHashCode(), "Sending message");
try
{
if (flag3)
{
messageItem.SendWithoutSavingMessage();
}
else
{
messageItem.Send();
}
if (null != base.FromParticipant)
{
Participant v = new Participant(base.UserContext.ExchangePrincipal);
if (!base.FromParticipant.AreAddressesEqual(v))
{
RecipientInfoCacheEntry fromRecipientEntry = base.GetFromRecipientEntry(base.FromParticipant.EmailAddress);
if (fromRecipientEntry != null)
{
RecipientCache recipientCache = SendFromCache.TryGetCache(base.UserContext);
if (recipientCache != null)
{
recipientCache.AddEntry(fromRecipientEntry);
}
}
}
}
}
catch (Exception ex)
{
ExTraceGlobals.MailDataTracer.TraceError <string>((long)this.GetHashCode(), "EditMessageEventHandler.ProcessMessageRequestmessage - Exception: {0}", ex.Message);
if (Utilities.ShouldSendChangeKeyForException(ex))
{
ExTraceGlobals.MailDataTracer.TraceDebug <string>((long)this.GetHashCode(), "EditMessageEventHandler.ProcessMessageRequestmessage attempt to send change key on exception: {0}", ex.Message);
base.SaveIdAndChangeKeyInCustomErrorInfo(messageItem);
}
throw;
}
if (Globals.ArePerfCountersEnabled)
{
OwaSingleCounters.MessagesSent.Increment();
if (flag4)
{
OwaSingleCounters.IRMMessagesSent.Increment();
}
}
}
}
}
finally
{
if (messageItem != null)
{
messageItem.Dispose();
messageItem = null;
}
}
}
// Token: 0x0600155B RID: 5467 RVA: 0x0007CE68 File Offset: 0x0007B068
protected void CopyMessageContents(MessageItem source, MessageItem destination, bool copyOriginalRecipients, Item attachmentItem)
{
source.Load();
string inReplyTo = destination.InReplyTo;
string references = destination.References;
destination.Subject = ((source.TryGetProperty(ItemSchema.SubjectPrefix) as string) ?? string.Empty) + ((source.TryGetProperty(ItemSchema.NormalizedSubject) as string) ?? string.Empty);
destination.InReplyTo = inReplyTo;
destination.Importance = source.Importance;
destination.InternetMessageId = source.InternetMessageId;
destination.Categories.Clear();
destination.Categories.AddRange(source.Categories);
destination.IconIndex = source.IconIndex;
destination.IsRead = source.IsRead;
destination.IsReadReceiptRequested = source.IsReadReceiptRequested;
destination.References = references;
if (copyOriginalRecipients)
{
this.originalRecipients = new HashSet <RecipientId>();
foreach (Recipient recipient in destination.Recipients)
{
this.originalRecipients.Add(recipient.Id);
}
}
destination.Recipients.Clear();
foreach (Recipient recipient2 in source.Recipients)
{
destination.Recipients.Add(recipient2.Participant, recipient2.RecipientItemType);
}
if (source.ReplyTo != null)
{
foreach (Participant item in source.ReplyTo)
{
destination.ReplyTo.Add(item);
}
}
RightsManagedMessageItem rightsManagedMessageItem = destination as RightsManagedMessageItem;
AttachmentCollection attachmentCollection = (rightsManagedMessageItem != null) ? rightsManagedMessageItem.ProtectedAttachmentCollection : destination.AttachmentCollection;
if (rightsManagedMessageItem == null && attachmentItem != null)
{
throw new InvalidOperationException("attachmentItem must be null for non-IRM messages");
}
if (this.ReplaceMime || attachmentItem != null)
{
if (rightsManagedMessageItem == null)
{
Body.CopyBody(source, destination, GlobalSettings.DisableCharsetDetectionInCopyMessageContents);
}
else
{
using (Stream stream = source.Body.OpenReadStream(new BodyReadConfiguration(source.Body.Format, source.Body.Charset)))
{
using (Stream stream2 = rightsManagedMessageItem.ProtectedBody.OpenWriteStream(new BodyWriteConfiguration(source.Body.Format, source.Body.Charset)))
{
Util.StreamHandler.CopyStreamData(stream, stream2);
}
}
}
}
foreach (AttachmentHandle handle in source.AttachmentCollection)
{
using (Attachment attachment = source.AttachmentCollection.Open(handle))
{
int num = 0;
if (attachment is StreamAttachment)
{
num = 1;
}
else if (attachment is OleAttachment)
{
num = 2;
}
if (num > 0)
{
Microsoft.Exchange.Data.Storage.AttachmentType type = (num == 1) ? Microsoft.Exchange.Data.Storage.AttachmentType.Stream : Microsoft.Exchange.Data.Storage.AttachmentType.Ole;
StreamAttachmentBase streamAttachmentBase = (StreamAttachmentBase)attachment;
using (StreamAttachmentBase streamAttachmentBase2 = (StreamAttachmentBase)attachmentCollection.Create(type))
{
using (Stream contentStream = streamAttachmentBase2.GetContentStream())
{
using (Stream contentStream2 = streamAttachmentBase.GetContentStream())
{
int num2 = 4096;
byte[] buffer = new byte[num2];
int count;
while ((count = contentStream2.Read(buffer, 0, num2)) > 0)
{
contentStream.Write(buffer, 0, count);
}
streamAttachmentBase2.ContentType = streamAttachmentBase.ContentType;
streamAttachmentBase2[AttachmentSchema.DisplayName] = streamAttachmentBase.DisplayName;
streamAttachmentBase2.FileName = streamAttachmentBase.FileName;
streamAttachmentBase2[AttachmentSchema.AttachContentId] = streamAttachmentBase[AttachmentSchema.AttachContentId];
streamAttachmentBase2.IsInline = streamAttachmentBase.IsInline;
}
}
streamAttachmentBase2.Save();
continue;
}
}
ItemAttachment itemAttachment = (ItemAttachment)attachment;
using (Item item2 = itemAttachment.GetItem())
{
using (ItemAttachment itemAttachment2 = attachmentCollection.AddExistingItem(item2))
{
itemAttachment2.Save();
}
}
}
}
if (attachmentItem != null)
{
using (ItemAttachment itemAttachment3 = attachmentCollection.AddExistingItem(attachmentItem))
{
itemAttachment3.Save();
}
}
}
// 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);
}
