private static string ItemClassFromResponseType(string itemClassPrefix, ResponseType responseType)
{
bool flag = ObjectClass.IsMeetingResponseSeries(itemClassPrefix);
string result;
switch (responseType)
{
case ResponseType.Tentative:
result = (flag ? "IPM.MeetingMessageSeries.Resp.Tent" : "IPM.Schedule.Meeting.Resp.Tent");
break;
case ResponseType.Accept:
result = (flag ? "IPM.MeetingMessageSeries.Resp.Pos" : "IPM.Schedule.Meeting.Resp.Pos");
break;
case ResponseType.Decline:
result = (flag ? "IPM.MeetingMessageSeries.Resp.Neg" : "IPM.Schedule.Meeting.Resp.Neg");
break;
default:
throw new ArgumentException(ServerStrings.ExUnknownResponseType, "responseType");
}
return(result);
}
internal static void ModifySubjectProperty(PropertyBag.BasicPropertyStore item, NativeStorePropertyDefinition property, string value)
{
string text = item.GetValue(InternalSchema.SubjectPrefixInternal) as string;
string text2 = item.GetValue(InternalSchema.NormalizedSubjectInternal) as string;
string text3 = item.GetValue(InternalSchema.MapiSubject) as string;
if (property == InternalSchema.NormalizedSubjectInternal)
{
text2 = value;
if (text3 != null)
{
string text4 = SubjectProperty.ExtractPrefixUsingNormalizedSubject(text3, text2);
if (text4 != null)
{
text = text4;
}
}
if (text == null)
{
text = string.Empty;
}
}
else if (property == InternalSchema.SubjectPrefixInternal)
{
text = value;
if (text3 != null && text3.StartsWith(text, StringComparison.Ordinal))
{
text2 = text3.Substring(text.Length);
}
if (text2 == null)
{
text2 = string.Empty;
}
}
else
{
if (property != InternalSchema.MapiSubject)
{
throw new ArgumentException("Not a supported subject property", "property");
}
if (!string.IsNullOrEmpty(text) && value.StartsWith(text, StringComparison.Ordinal))
{
text2 = value.Substring(text.Length);
}
else if (!string.IsNullOrEmpty(text2))
{
string text5 = SubjectProperty.ExtractPrefixUsingNormalizedSubject(value, text2);
if (text5 != null)
{
text = text5;
}
else
{
SubjectProperty.ComputeSubjectPrefix(value, out text, out text2);
}
}
else
{
SubjectProperty.ComputeSubjectPrefix(value, out text, out text2);
}
}
text3 = text + text2;
item.SetValueWithFixup(InternalSchema.SubjectPrefixInternal, text);
item.SetValueWithFixup(InternalSchema.NormalizedSubjectInternal, text2);
item.SetValueWithFixup(InternalSchema.MapiSubject, text3);
string itemClass = item.GetValue(InternalSchema.ItemClass) as string;
if (!ObjectClass.IsPost(itemClass))
{
item.SetValueWithFixup(InternalSchema.ConversationTopic, text2);
}
}
protected override StoreObjectType GetStoreObjectType(PropertyBag.BasicPropertyStore propertyBag)
{
return(ObjectClass.GetObjectType(propertyBag.GetValue(InternalSchema.ItemClass) as string));
}
internal static Charset GetItemOutboundMimeCharset(Item item, OutboundConversionOptions options)
{
Charset charset = ConvertUtils.GetItemOutboundMimeCharsetInternal(item, options);
string className = item.ClassName;
if (options.DetectionOptions.PreferredCharset == null && charset.CodePage != 54936 && (ObjectClass.IsTaskRequest(className) || ObjectClass.IsMeetingMessage(className) || ObjectClass.IsCalendarItem(className)))
{
charset = Charset.GetCharset(65001);
}
return(charset);
}
private void ParseRecipientTable()
{
string valueOrDefault = base.CoreItem.PropertyBag.GetValueOrDefault <string>(InternalSchema.ItemClass);
if (base.ConversionOptions.IsSenderTrusted || !base.MessageWriter.IsTopLevelWriter || ObjectClass.IsNonSendableWithRecipients(valueOrDefault) || ObjectClass.IsDsn(valueOrDefault))
{
TnefPropertyReader propertyReader = this.reader.PropertyReader;
while (propertyReader.ReadNextRow())
{
this.NewRecipient();
while (propertyReader.ReadNextProperty())
{
this.ParseTnefProperty(propertyReader, false);
}
this.EndRecipient();
this.isRecipientTablePromoted = true;
}
}
}
internal ReplyForwardCommon(Item originalItem, Item newItem, ReplyForwardConfiguration parameters, bool decodeSmime)
{
Util.ThrowOnNullArgument(parameters, "parameters");
if (decodeSmime && ObjectClass.IsSmime(originalItem.ClassName))
{
if (parameters.ConversionOptionsForSmime == null || parameters.ConversionOptionsForSmime.IgnoreImceaDomain || parameters.ConversionOptionsForSmime.ImceaEncapsulationDomain == null)
{
throw new InvalidOperationException("Cannot decode SMIME without valid ConversionOptionsForSmime");
}
this.originalItem = originalItem;
MessageItem messageItem = originalItem as MessageItem;
if (messageItem != null)
{
Item item = messageItem.FetchSmimeContent(parameters.ConversionOptionsForSmime.ImceaEncapsulationDomain);
if (item != null)
{
this.originalItem = item;
this.originalItem[InternalSchema.NormalizedSubjectInternal] = messageItem.GetValueOrDefault <string>(InternalSchema.NormalizedSubjectInternal, string.Empty);
this.originalItem[InternalSchema.Sender] = messageItem.Sender;
this.originalItem[InternalSchema.From] = messageItem.From;
}
}
}
else
{
this.originalItem = originalItem;
}
this.newItem = newItem;
this.parameters = parameters;
this.culture = ReplyForwardUtils.CalculateReplyForwardCulture(parameters.Culture, newItem);
if (this.culture == null)
{
throw new InvalidOperationException("Forward message culture is unknown");
}
this.FetchPropertiesFromOriginalItem();
if (originalItem is MessageItem)
{
if (originalItem.MapiMessage != null)
{
SetReadFlags readFlag = parameters.ShouldSuppressReadReceipt ? SetReadFlags.SuppressReceipt : SetReadFlags.None;
try
{
StoreSession session = originalItem.Session;
bool flag = false;
try
{
if (session != null)
{
session.BeginMapiCall();
session.BeginServerHealthCall();
flag = true;
}
if (StorageGlobals.MapiTestHookBeforeCall != null)
{
StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod());
}
originalItem.MapiMessage.SetReadFlag(readFlag);
}
catch (MapiPermanentException ex)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotSetReadFlags, ex, session, this, "{0}. MapiException = {1}.", new object[]
{
string.Format("ReplyForwardCommon::ctor.", new object[0]),
ex
});
}
catch (MapiRetryableException ex2)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotSetReadFlags, ex2, session, this, "{0}. MapiException = {1}.", new object[]
{
string.Format("ReplyForwardCommon::ctor.", new object[0]),
ex2
});
}
finally
{
try
{
if (session != null)
{
session.EndMapiCall();
if (flag)
{
session.EndServerHealthCall();
}
}
}
finally
{
if (StorageGlobals.MapiTestHookAfterCall != null)
{
StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod());
}
}
}
}
catch (StoragePermanentException)
{
}
catch (StorageTransientException)
{
}
}
(this.originalItem as MessageItem).IsRead = true;
}
else if (this.originalItem is CalendarItemOccurrence)
{
this.parentPropValues[ParentPropertyIndex.IsRecurring] = true;
this.parentPropValues[ParentPropertyIndex.AppointmentRecurring] = false;
this.parentPropValues[ParentPropertyIndex.RecurrenceType] = 0;
this.parentPropValues[ParentPropertyIndex.TimeZoneBlob] = new PropertyError(InternalSchema.TimeZoneBlob, PropertyErrorCode.NotFound);
this.parentPropValues[ParentPropertyIndex.AppointmentRecurrenceBlob] = new PropertyError(InternalSchema.AppointmentRecurrenceBlob, PropertyErrorCode.NotFound);
this.parentPropValues[ParentPropertyIndex.IsException] = true;
if (string.IsNullOrEmpty(this.parentPropValues[ParentPropertyIndex.RecurrencePattern] as string))
{
CalendarItemOccurrence calendarItemOccurrence = this.originalItem as CalendarItemOccurrence;
this.parentPropValues[ParentPropertyIndex.RecurrencePattern] = calendarItemOccurrence.OccurrencePropertyBag.MasterCalendarItem.GenerateWhen();
}
}
string valueOrDefault = originalItem.GetValueOrDefault <string>(InternalSchema.ItemClass, string.Empty);
this.originalItemSigned = (ObjectClass.IsOfClass(valueOrDefault, "IPM.Note.Secure.Sign") || ObjectClass.IsSmimeClearSigned(valueOrDefault));
if (!this.originalItemSigned)
{
this.originalItemEncrypted = (ObjectClass.IsOfClass(valueOrDefault, "IPM.Note.Secure") || ObjectClass.IsSmime(valueOrDefault));
}
string valueOrDefault2 = originalItem.GetValueOrDefault <string>(InternalSchema.ContentClass, string.Empty);
this.originalItemIrm = ObjectClass.IsRightsManagedContentClass(valueOrDefault2);
}
private static Notification CreateNotification(MapiNotification notification)
{
Notification result;
if (notification.NotificationType == AdviseFlags.NewMail)
{
MapiNewMailNotification mapiNewMailNotification = notification as MapiNewMailNotification;
result = new NewMailNotification(StoreObjectId.FromProviderSpecificId(mapiNewMailNotification.EntryId, ObjectClass.GetObjectType(mapiNewMailNotification.MessageClass)), StoreObjectId.FromProviderSpecificId(mapiNewMailNotification.ParentId, StoreObjectType.Folder), mapiNewMailNotification.MessageClass, (MessageFlags)mapiNewMailNotification.MessageFlags);
}
else if (notification.NotificationType == AdviseFlags.SearchComplete)
{
result = new ObjectNotification(null, null, null, null, (NotificationObjectType)0, null, NotificationType.SearchComplete);
}
else if (notification.NotificationType == AdviseFlags.ConnectionDropped)
{
MapiConnectionDroppedNotification mapiConnectionDroppedNotification = notification as MapiConnectionDroppedNotification;
result = new ConnectionDroppedNotification(mapiConnectionDroppedNotification.ServerDN, mapiConnectionDroppedNotification.UserDN, mapiConnectionDroppedNotification.TickDeath);
}
else
{
MapiObjectNotification mapiObjectNotification = notification as MapiObjectNotification;
if (mapiObjectNotification == null)
{
throw new InvalidOperationException(ServerStrings.ExNotSupportedNotificationType((uint)notification.NotificationType));
}
AdviseFlags notificationType = notification.NotificationType;
NotificationType type;
if (notificationType <= AdviseFlags.ObjectDeleted)
{
if (notificationType == AdviseFlags.ObjectCreated)
{
type = NotificationType.Created;
goto IL_10A;
}
if (notificationType == AdviseFlags.ObjectDeleted)
{
type = NotificationType.Deleted;
goto IL_10A;
}
}
else
{
if (notificationType == AdviseFlags.ObjectModified)
{
type = NotificationType.Modified;
goto IL_10A;
}
if (notificationType == AdviseFlags.ObjectMoved)
{
type = NotificationType.Moved;
goto IL_10A;
}
if (notificationType == AdviseFlags.ObjectCopied)
{
type = NotificationType.Copied;
goto IL_10A;
}
}
throw new InvalidOperationException(ServerStrings.ExNotSupportedNotificationType((uint)notification.NotificationType));
IL_10A:
UnresolvedPropertyDefinition[] propertyDefinitions;
if (mapiObjectNotification.Tags != null)
{
propertyDefinitions = PropertyTagCache.UnresolvedPropertyDefinitionsFromPropTags(mapiObjectNotification.Tags);
}
else
{
propertyDefinitions = Array <UnresolvedPropertyDefinition> .Empty;
}
result = new ObjectNotification((mapiObjectNotification.EntryId == null) ? null : StoreObjectId.FromProviderSpecificId(mapiObjectNotification.EntryId, StoreObjectType.Unknown), (mapiObjectNotification.ParentId == null) ? null : StoreObjectId.FromProviderSpecificId(mapiObjectNotification.ParentId, StoreObjectType.Folder), (mapiObjectNotification.OldId == null) ? null : StoreObjectId.FromProviderSpecificId(mapiObjectNotification.OldId, StoreObjectType.Unknown), (mapiObjectNotification.OldParentId == null) ? null : StoreObjectId.FromProviderSpecificId(mapiObjectNotification.OldParentId, StoreObjectType.Folder), (NotificationObjectType)mapiObjectNotification.ObjectType, propertyDefinitions, type);
}
return(result);
}
internal static bool IsFolderTreeData(IStorePropertyBag row)
{
string valueOrDefault = row.GetValueOrDefault <string>(StoreObjectSchema.ItemClass, string.Empty);
return(ObjectClass.IsFolderTreeData(valueOrDefault));
}
public bool SkipItemOperation(COWSettings settings, IDumpsterItemOperations dumpster, COWTriggerAction operation, COWTriggerActionState state, StoreSession session, StoreObjectId itemId, CoreItem item, bool onBeforeNotification, bool onDumpster, bool success, CallbackContext callbackContext)
{
if (!COWContactLogging.COWContactLoggingConfiguration.Instance.IsLoggingEnabled())
{
return(true);
}
Util.ThrowOnNullArgument(session, "session");
EnumValidator.ThrowIfInvalid <COWTriggerAction>(operation, "operation");
EnumValidator.ThrowIfInvalid <COWTriggerActionState>(state, "state");
if (item == null)
{
COWContactLogging.Tracer.TraceDebug((long)this.GetHashCode(), "COWContactLogging.SkipItemOperation: Item is null");
return(true);
}
if (!onBeforeNotification)
{
COWContactLogging.Tracer.TraceDebug((long)this.GetHashCode(), "COWContactLogging.SkipItemOperation: Not onBeforeNotification");
return(true);
}
string valueOrDefault = item.PropertyBag.GetValueOrDefault <string>(StoreObjectSchema.ItemClass, string.Empty);
COWContactLogging.Tracer.TraceDebug <string>((long)this.GetHashCode(), "COWContactLogging.SkipItemOperation: ItemClass: {0}", valueOrDefault);
if (ObjectClass.IsPlace(valueOrDefault))
{
return(true);
}
if (!ObjectClass.IsContact(valueOrDefault) && !ObjectClass.IsDistributionList(valueOrDefault) && !ObjectClass.IsContactsFolder(valueOrDefault))
{
return(true);
}
foreach (IContactChangeTracker contactChangeTracker in COWContactLogging.ChangeTrackers)
{
if (contactChangeTracker.ShouldLoadPropertiesForFurtherCheck(operation, valueOrDefault, itemId, item))
{
COWContactLogging.Tracer.TraceDebug((long)this.GetHashCode(), "COWContactLogging.SkipItemOperation: A tracker interested.");
return(false);
}
}
return(true);
}
public ICoreItem OpenAttachedItem(ICollection <PropertyDefinition> propertiesToLoad, AttachmentPropertyBag attachmentBag, bool isNew)
{
MapiMessage mapiMessage = null;
PersistablePropertyBag persistablePropertyBag = null;
CoreItem coreItem = null;
bool flag = false;
StoreObjectId storeObjectId = null;
byte[] array = null;
ICoreItem result;
try
{
StoreObjectPropertyBag storeObjectPropertyBag = (StoreObjectPropertyBag)attachmentBag.PersistablePropertyBag;
MapiAttach mapiAttach = (MapiAttach)storeObjectPropertyBag.MapiProp;
StoreSession session = this.AttachmentCollection.ContainerItem.Session;
OpenPropertyFlags openPropertyFlags = isNew ? OpenPropertyFlags.Create : (this.AttachmentCollection.IsReadOnly ? OpenPropertyFlags.BestAccess : OpenPropertyFlags.BestAccess);
openPropertyFlags |= OpenPropertyFlags.DeferredErrors;
string text = storeObjectPropertyBag.TryGetProperty(InternalSchema.ItemClass) as string;
Schema schema = (text != null) ? ObjectClass.GetSchema(text) : MessageItemSchema.Instance;
propertiesToLoad = InternalSchema.Combine <PropertyDefinition>(schema.AutoloadProperties, propertiesToLoad);
StoreSession session2 = this.AttachmentCollection.ContainerItem.Session;
bool flag2 = false;
try
{
if (session2 != null)
{
session2.BeginMapiCall();
session2.BeginServerHealthCall();
flag2 = true;
}
if (StorageGlobals.MapiTestHookBeforeCall != null)
{
StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod());
}
mapiMessage = mapiAttach.OpenEmbeddedMessage(openPropertyFlags);
}
catch (MapiPermanentException ex)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotOpenEmbeddedMessage, ex, session2, this, "{0}. MapiException = {1}.", new object[]
{
string.Format("MapiAttachmentProvider::OpenAttachedItem", new object[0]),
ex
});
}
catch (MapiRetryableException ex2)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotOpenEmbeddedMessage, ex2, session2, this, "{0}. MapiException = {1}.", new object[]
{
string.Format("MapiAttachmentProvider::OpenAttachedItem", new object[0]),
ex2
});
}
finally
{
try
{
if (session2 != null)
{
session2.EndMapiCall();
if (flag2)
{
session2.EndServerHealthCall();
}
}
}
finally
{
if (StorageGlobals.MapiTestHookAfterCall != null)
{
StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod());
}
}
}
persistablePropertyBag = new StoreObjectPropertyBag(session, mapiMessage, propertiesToLoad);
if (!isNew)
{
StoreObjectType storeObjectType = ItemBuilder.ReadStoreObjectTypeFromPropertyBag(persistablePropertyBag);
ItemCreateInfo itemCreateInfo = ItemCreateInfo.GetItemCreateInfo(storeObjectType);
propertiesToLoad = InternalSchema.Combine <PropertyDefinition>(itemCreateInfo.Schema.AutoloadProperties, propertiesToLoad);
if (this.AttachmentCollection.IsReadOnly)
{
StoreId.SplitStoreObjectIdAndChangeKey(StoreObjectId.DummyId, out storeObjectId, out array);
}
persistablePropertyBag = new AcrPropertyBag(persistablePropertyBag, itemCreateInfo.AcrProfile, storeObjectId, new RetryBagFactory(session), array);
}
coreItem = new CoreItem(session, persistablePropertyBag, storeObjectId, array, isNew ? Origin.New : Origin.Existing, ItemLevel.Attached, propertiesToLoad, ItemBindOption.None);
if (text != null && isNew)
{
coreItem.PropertyBag[InternalSchema.ItemClass] = text;
}
flag = true;
result = coreItem;
}
finally
{
if (!flag)
{
if (coreItem != null)
{
coreItem.Dispose();
coreItem = null;
}
if (persistablePropertyBag != null)
{
persistablePropertyBag.Dispose();
persistablePropertyBag = null;
}
if (mapiMessage != null)
{
mapiMessage.Dispose();
mapiMessage = null;
}
}
}
return(result);
}
public static Stream OpenRestrictedAttachment(StreamAttachment sourceAttachment, OrganizationId orgId, string userIdentity, SecurityIdentifier userSid, RecipientTypeDetails userType, out UseLicenseAndUsageRights validatedUseLicenseAndUsageRights, out bool acquiredNewLicense)
{
StreamAttachment.< > c__DisplayClass2 CS$ < > 8__locals1 = new StreamAttachment.< > c__DisplayClass2();
CS$ < > 8__locals1.sourceAttachment = sourceAttachment;
CS$ < > 8__locals1.orgId = orgId;
CS$ < > 8__locals1.userIdentity = userIdentity;
CS$ < > 8__locals1.userSid = userSid;
CS$ < > 8__locals1.userType = userType;
Util.ThrowOnNullArgument(CS$ < > 8__locals1.sourceAttachment, "sourceAttachment");
Util.ThrowOnNullArgument(CS$ < > 8__locals1.orgId, "orgId");
Util.ThrowOnNullArgument(CS$ < > 8__locals1.userIdentity, "userIdentity");
Util.ThrowOnNullArgument(CS$ < > 8__locals1.userSid, "userSid");
if (!Enum.IsDefined(typeof(RecipientTypeDetails), CS$ < > 8__locals1.userType))
{
throw new EnumArgumentException("userType");
}
CS$ < > 8__locals1.cachedServerUseLicense = null;
if (!PropertyError.IsPropertyNotFound(CS$ < > 8__locals1.sourceAttachment.TryGetProperty(AttachmentSchema.DRMServerLicenseCompressed)))
{
using (Stream stream = CS$ < > 8__locals1.sourceAttachment.OpenPropertyStream(AttachmentSchema.DRMServerLicenseCompressed, PropertyOpenMode.ReadOnly))
{
CS$ < > 8__locals1.cachedServerUseLicense = DrmEmailCompression.DecompressUseLicense(stream);
}
}
StreamAttachment.< > c__DisplayClass2 CS$ < > 8__locals2 = CS$ < > 8__locals1;
int?valueAsNullable = CS$ < > 8__locals1.sourceAttachment.PropertyBag.GetValueAsNullable <int>(AttachmentSchema.DRMRights);
CS$ < > 8__locals2.cachedUsageRights = ((valueAsNullable != null) ? new ContentRight?((ContentRight)valueAsNullable.GetValueOrDefault()) : null);
CS$ < > 8__locals1.cachedExpiryTime = CS$ < > 8__locals1.sourceAttachment.PropertyBag.GetValueAsNullable <ExDateTime>(AttachmentSchema.DRMExpiryTime);
CS$ < > 8__locals1.cachedDrmPropsSignature = CS$ < > 8__locals1.sourceAttachment.PropertyBag.GetValueOrDefault <byte[]>(AttachmentSchema.DRMPropsSignature);
CS$ < > 8__locals1.item = CS$ < > 8__locals1.sourceAttachment.CoreAttachment.ParentCollection.ContainerItem;
if (string.IsNullOrEmpty(CS$ < > 8__locals1.cachedServerUseLicense) || CS$ < > 8__locals1.cachedUsageRights == null || CS$ < > 8__locals1.cachedExpiryTime == null || CS$ < > 8__locals1.cachedDrmPropsSignature == null)
{
string valueOrDefault = CS$ < > 8__locals1.item.PropertyBag.GetValueOrDefault <string>(StoreObjectSchema.ItemClass, string.Empty);
if (ObjectClass.IsMessage(valueOrDefault, false))
{
CS$ < > 8__locals1.cachedServerUseLicense = CS$ < > 8__locals1.item.PropertyBag.GetValueOrDefault <string>(MessageItemSchema.DRMServerLicense, string.Empty);
StreamAttachment.< > c__DisplayClass2 CS$ < > 8__locals3 = CS$ < > 8__locals1;
int?valueAsNullable2 = CS$ < > 8__locals1.item.PropertyBag.GetValueAsNullable <int>(MessageItemSchema.DRMRights);
CS$ < > 8__locals3.cachedUsageRights = ((valueAsNullable2 != null) ? new ContentRight?((ContentRight)valueAsNullable2.GetValueOrDefault()) : null);
CS$ < > 8__locals1.cachedExpiryTime = CS$ < > 8__locals1.item.PropertyBag.GetValueAsNullable <ExDateTime>(MessageItemSchema.DRMExpiryTime);
CS$ < > 8__locals1.cachedDrmPropsSignature = CS$ < > 8__locals1.item.PropertyBag.GetValueOrDefault <byte[]>(MessageItemSchema.DRMPropsSignature);
}
}
CS$ < > 8__locals1.unprotectionSuccess = false;
CS$ < > 8__locals1.useLicenseAndUsageRights = null;
CS$ < > 8__locals1.validCachedLicense = false;
Stream unprotectedAttachment;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
StreamAttachment.< > c__DisplayClass4 CS$ < > 8__locals4 = new StreamAttachment.< > c__DisplayClass4();
CS$ < > 8__locals4.unprotectedAttachment = disposeGuard.Add <Stream>(Streams.CreateTemporaryStorageStream());
CS$ < > 8__locals4.decryptorHandle = null;
using (Stream inputStream = CS$ < > 8__locals1.sourceAttachment.GetContentStream(PropertyOpenMode.ReadOnly))
{
try
{
MsgToRpMsgConverter.CallRM(delegate
{
CS$ < > 8__locals1.unprotectionSuccess = ProtectorsManager.Instance.Unprotect(delegate(string protectedDocumentIssuanceLicense)
{
string valueOrDefault2 = CS$ < > 8__locals1.item.PropertyBag.GetValueOrDefault <string>(ItemSchema.InternetMessageId, string.Empty);
bool flag = string.IsNullOrEmpty(valueOrDefault2);
RmsClientManagerContext context = new RmsClientManagerContext(CS$ < > 8__locals1.orgId, flag ? RmsClientManagerContext.ContextId.AttachmentFileName : RmsClientManagerContext.ContextId.MessageId, flag ? CS$ < > 8__locals1.sourceAttachment.FileName : valueOrDefault2, null);
if (!string.IsNullOrEmpty(CS$ < > 8__locals1.cachedServerUseLicense) && CS$ < > 8__locals1.cachedUsageRights != null && CS$ < > 8__locals1.cachedExpiryTime != null && CS$ < > 8__locals1.cachedDrmPropsSignature != null)
{
try
{
CS$ < > 8__locals4.decryptorHandle = RmsClientManager.VerifyDRMPropsSignatureAndGetDecryptor(context, CS$ < > 8__locals1.userSid, CS$ < > 8__locals1.userType, CS$ < > 8__locals1.userIdentity, CS$ < > 8__locals1.cachedUsageRights.Value, CS$ < > 8__locals1.cachedExpiryTime.Value, CS$ < > 8__locals1.cachedDrmPropsSignature, CS$ < > 8__locals1.cachedServerUseLicense, protectedDocumentIssuanceLicense, UsageRightsSignatureVerificationOptions.LookupSidHistory, StreamAttachment.EmptySidList);
CS$ < > 8__locals1.validCachedLicense = true;
Uri licensingUri = null;
XmlNode[] array = null;
bool flag2;
RmsClientManager.GetLicensingUri(CS$ < > 8__locals1.orgId, protectedDocumentIssuanceLicense, out licensingUri, out array, out flag2);
CS$ < > 8__locals1.useLicenseAndUsageRights = new UseLicenseAndUsageRights(CS$ < > 8__locals1.cachedServerUseLicense, CS$ < > 8__locals1.cachedUsageRights.Value, CS$ < > 8__locals1.cachedExpiryTime.Value, CS$ < > 8__locals1.cachedDrmPropsSignature, CS$ < > 8__locals1.orgId, protectedDocumentIssuanceLicense, licensingUri);
}
catch (BadDRMPropsSignatureException)
{
}
}
if (CS$ < > 8__locals1.useLicenseAndUsageRights == null)
{
CS$ < > 8__locals1.useLicenseAndUsageRights = RmsClientManager.AcquireUseLicenseAndUsageRights(context, protectedDocumentIssuanceLicense, CS$ < > 8__locals1.userIdentity, CS$ < > 8__locals1.userSid, CS$ < > 8__locals1.userType);
if (CS$ < > 8__locals4.decryptorHandle != null)
{
CS$ < > 8__locals4.decryptorHandle.Close();
CS$ < > 8__locals4.decryptorHandle = null;
}
RmsClientManager.BindUseLicenseForDecryption(context, CS$ < > 8__locals1.useLicenseAndUsageRights.LicensingUri, CS$ < > 8__locals1.useLicenseAndUsageRights.UseLicense, CS$ < > 8__locals1.useLicenseAndUsageRights.PublishingLicense, out CS$ < > 8__locals4.decryptorHandle);
}
return(CS$ < > 8__locals4.decryptorHandle);
}, CS$ < > 8__locals1.sourceAttachment.FileName, inputStream, CS$ < > 8__locals4.unprotectedAttachment);
}, ServerStrings.FailedToUnprotectAttachment(CS$ < > 8__locals1.sourceAttachment.FileName));
}
private ContactLinkingProcessingState InspectNotification(COWTriggerAction operation, StoreSession session, CoreItem item, bool onBeforeNotification, bool onDumpster)
{
if (onDumpster)
{
return(ContactLinkingProcessingState.DoNotProcess);
}
if (!onBeforeNotification)
{
return(ContactLinkingProcessingState.DoNotProcess);
}
if (item == null)
{
return(ContactLinkingProcessingState.Unknown);
}
if (!(session is MailboxSession))
{
COWContactLinking.Tracer.TraceDebug((long)this.GetHashCode(), "COWContactLinking.InspectNotification: not a mailbox session.");
return(ContactLinkingProcessingState.DoNotProcess);
}
if (operation != COWTriggerAction.Create && operation != COWTriggerAction.Update)
{
COWContactLinking.Tracer.TraceDebug((long)this.GetHashCode(), "COWContactLinking.InspectNotification: not an Create or Update operation.");
return(ContactLinkingProcessingState.DoNotProcess);
}
PersistablePropertyBag persistablePropertyBag = CoreObject.GetPersistablePropertyBag(item);
switch (persistablePropertyBag.Context.AutomaticContactLinkingAction)
{
case AutomaticContactLinkingAction.ClientBased:
if (!this.IsClientAllowed(session.ClientInfoString))
{
COWContactLinking.Tracer.TraceDebug((long)this.GetHashCode(), "COWContactLinking.InspectNotification: not allowed client session.");
return(ContactLinkingProcessingState.DoNotProcess);
}
break;
case AutomaticContactLinkingAction.Ignore:
COWContactLinking.Tracer.TraceDebug((long)this.GetHashCode(), "COWContactLinking.InspectNotification: IgnoreAutomaticContactLinking=true.");
return(ContactLinkingProcessingState.DoNotProcess);
}
if (session.LogonType != LogonType.Owner && session.LogonType != LogonType.Delegated)
{
COWContactLinking.Tracer.TraceDebug((long)this.GetHashCode(), "COWContactLinking.InspectNotification: logon session is not user or delegated.");
return(ContactLinkingProcessingState.DoNotProcess);
}
string valueOrDefault = item.PropertyBag.GetValueOrDefault <string>(StoreObjectSchema.ItemClass, string.Empty);
if (string.IsNullOrEmpty(valueOrDefault))
{
return(ContactLinkingProcessingState.Unknown);
}
if (ObjectClass.IsPlace(valueOrDefault))
{
COWContactLinking.Tracer.TraceDebug((long)this.GetHashCode(), "COWContactLinking.InspectNotification: place item class are not processed.");
return(ContactLinkingProcessingState.DoNotProcess);
}
if (!ObjectClass.IsContact(valueOrDefault))
{
COWContactLinking.Tracer.TraceDebug((long)this.GetHashCode(), "COWContactLinking.InspectNotification: item class is not contact.");
return(ContactLinkingProcessingState.DoNotProcess);
}
if (operation == COWTriggerAction.Update && !Array.Exists <StorePropertyDefinition>(COWContactLinking.NotificationProperties, (StorePropertyDefinition property) => item.PropertyBag.IsPropertyDirty(property)))
{
COWContactLinking.Tracer.TraceDebug((long)this.GetHashCode(), "COWContactLinking.InspectNotification: no relevant properties changed");
return(ContactLinkingProcessingState.Unknown);
}
if (ClientInfo.MOMT.IsMatch(session.ClientInfoString))
{
return(ContactLinkingProcessingState.ProcessAfterSave);
}
return(ContactLinkingProcessingState.ProcessBeforeSave);
}
protected override object InternalTryGetValue(PropertyBag.BasicPropertyStore propertyBag)
{
bool? flag = null;
string valueOrDefault = propertyBag.GetValueOrDefault <string>(InternalSchema.ItemClass, string.Empty);
if (ObjectClass.IsCalendarItemCalendarItemOccurrenceOrRecurrenceException(valueOrDefault) || ObjectClass.IsCalendarItemSeries(valueOrDefault))
{
AppointmentStateFlags valueOrDefault2 = propertyBag.GetValueOrDefault <AppointmentStateFlags>(InternalSchema.AppointmentStateInternal);
flag = new bool?(IsOrganizerProperty.GetForCalendarItem(valueOrDefault, valueOrDefault2));
}
else if (ObjectClass.IsMeetingMessage(valueOrDefault))
{
MeetingMessage meetingMessage = propertyBag.Context.StoreObject as MeetingMessage;
if (meetingMessage != null)
{
CalendarItemBase calendarItemBase = null;
try
{
calendarItemBase = meetingMessage.GetCorrelatedItemInternal(true);
}
catch (CorruptDataException)
{
}
catch (CorrelationFailedException)
{
}
if (calendarItemBase != null)
{
flag = new bool?(calendarItemBase.IsOrganizer());
}
else if (!(meetingMessage is MeetingResponse))
{
flag = new bool?(meetingMessage.IsMailboxOwnerTheSender());
}
}
}
if (flag != null)
{
return(flag);
}
return(new PropertyError(this, PropertyErrorCode.NotFound));
}
internal static bool GetForCalendarItem(string messageClass, AppointmentStateFlags flags)
{
if (!ObjectClass.IsCalendarItemCalendarItemOccurrenceOrRecurrenceException(messageClass) && !ObjectClass.IsCalendarItemSeries(messageClass))
{
throw new ArgumentException(string.Format("[IsOrganizerProperty.GetForCalendarItem] Message class MUST be a calendar item occurrence or recurrence exception in order to call this method. ItemClass: {0}", messageClass));
}
return((flags & AppointmentStateFlags.Received) == AppointmentStateFlags.None);
}
internal static bool CanConvertToMeetingMessage(Item item)
{
return(CalendarUtil.GetICalMethod(item) != CalendarMethod.None || ObjectClass.IsFailedInboundICal(item.ClassName));
}
private void ReadFromMessageProperties(MessageItem messageItem)
{
SharingFlavor?valueAsNullable = messageItem.GetValueAsNullable <SharingFlavor>(InternalSchema.SharingFlavor);
if (valueAsNullable == null)
{
ExTraceGlobals.SharingTracer.TraceError <string>((long)this.GetHashCode(), "{0}: SharingFlavor is missing", messageItem.Session.UserLegacyDN);
throw new InvalidSharingMessageException("SharingFlavor");
}
this.context.SharingFlavor = valueAsNullable.Value;
SharingCapabilities?valueAsNullable2 = messageItem.GetValueAsNullable <SharingCapabilities>(InternalSchema.SharingCapabilities);
if (valueAsNullable2 == null)
{
ExTraceGlobals.SharingTracer.TraceDebug <string>((long)this.GetHashCode(), "{0}: SharingCapabilities is missing, use default value", messageItem.Session.UserLegacyDN);
this.context.SetDefaultCapabilities();
}
else
{
this.context.SharingCapabilities = valueAsNullable2.Value;
}
string valueOrDefault = messageItem.GetValueOrDefault <string>(InternalSchema.SharingInitiatorName, null);
if (valueOrDefault == null)
{
ExTraceGlobals.SharingTracer.TraceError <string>((long)this.GetHashCode(), "{0}: SharingInitiatorName is missing.", messageItem.Session.UserLegacyDN);
throw new InvalidSharingMessageException("SharingInitiatorName");
}
this.context.InitiatorName = valueOrDefault;
string valueOrDefault2 = messageItem.GetValueOrDefault <string>(InternalSchema.SharingInitiatorSmtp, null);
if (valueOrDefault2 == null)
{
ExTraceGlobals.SharingTracer.TraceError <string>((long)this.GetHashCode(), "{0}: SharingInitiatorSmtp is missing.", messageItem.Session.UserLegacyDN);
throw new InvalidSharingMessageException("SharingInitiatorSmtp");
}
if (!SmtpAddress.IsValidSmtpAddress(valueOrDefault2))
{
ExTraceGlobals.SharingTracer.TraceError <string, string>((long)this.GetHashCode(), "{0}: SharingInitiatorSmtp is invalid: {1}", messageItem.Session.UserLegacyDN, valueOrDefault2);
throw new InvalidSharingMessageException("SharingInitiatorSmtp");
}
this.context.InitiatorSmtpAddress = valueOrDefault2;
byte[] valueOrDefault3 = messageItem.GetValueOrDefault <byte[]>(InternalSchema.SharingInitiatorEntryId, null);
if (valueOrDefault3 == null)
{
ExTraceGlobals.SharingTracer.TraceError <string>((long)this.GetHashCode(), "{0}: SharingInitiatorEntryId is missing.", messageItem.Session.UserLegacyDN);
throw new InvalidSharingMessageException("SharingInitiatorEntryId");
}
if (!AddressBookEntryId.IsAddressBookEntryId(valueOrDefault3))
{
ExTraceGlobals.SharingTracer.TraceError <string, byte[]>((long)this.GetHashCode(), "{0}: SharingInitiatorEntryId is invalid: {1}", messageItem.Session.UserLegacyDN, valueOrDefault3);
throw new InvalidSharingMessageException("SharingInitiatorEntryId");
}
this.context.InitiatorEntryId = valueOrDefault3;
string valueOrDefault4 = messageItem.GetValueOrDefault <string>(InternalSchema.SharingRemoteType, null);
if (valueOrDefault4 == null)
{
ExTraceGlobals.SharingTracer.TraceError <string>((long)this.GetHashCode(), "{0}: SharingRemoteType is missing.", messageItem.Session.UserLegacyDN);
throw new InvalidSharingMessageException("SharingRemoteType");
}
if (SharingDataType.FromContainerClass(valueOrDefault4) == null)
{
ExTraceGlobals.SharingTracer.TraceError <string, string>((long)this.GetHashCode(), "{0}: SharingRemoteType is invalid: {1}.", messageItem.Session.UserLegacyDN, valueOrDefault4);
throw new InvalidSharingMessageException("SharingRemoteType");
}
this.context.FolderClass = valueOrDefault4;
string valueOrDefault5 = messageItem.GetValueOrDefault <string>(InternalSchema.SharingRemoteName, null);
if (valueOrDefault5 == null)
{
ExTraceGlobals.SharingTracer.TraceError <string>((long)this.GetHashCode(), "{0}: SharingRemoteName is missing.", messageItem.Session.UserLegacyDN);
throw new InvalidSharingMessageException("SharingRemoteName");
}
this.context.FolderName = valueOrDefault5;
string valueOrDefault6 = messageItem.GetValueOrDefault <string>(InternalSchema.SharingRemoteUid, null);
if (valueOrDefault6 == null)
{
ExTraceGlobals.SharingTracer.TraceError <string>((long)this.GetHashCode(), "{0}: SharingRemoteUid is missing.", messageItem.Session.UserLegacyDN);
throw new InvalidSharingMessageException("SharingRemoteUid");
}
try
{
this.context.FolderId = StoreObjectId.FromHexEntryId(valueOrDefault6, ObjectClass.GetObjectType(valueOrDefault4));
}
catch (CorruptDataException)
{
ExTraceGlobals.SharingTracer.TraceError <string, string>((long)this.GetHashCode(), "{0}: SharingRemoteUid is invalid: {1}", messageItem.Session.UserLegacyDN, valueOrDefault6);
throw new InvalidSharingMessageException("SharingRemoteUid");
}
string valueOrDefault7 = messageItem.GetValueOrDefault <string>(InternalSchema.SharingRemoteStoreUid, null);
if (valueOrDefault7 == null)
{
ExTraceGlobals.SharingTracer.TraceError <string>((long)this.GetHashCode(), "{0}: SharingRemoteStoreUid is missing.", messageItem.Session.UserLegacyDN);
throw new InvalidSharingMessageException("SharingRemoteStoreUid");
}
byte[] array = null;
try
{
array = HexConverter.HexStringToByteArray(valueOrDefault7);
}
catch (FormatException)
{
}
if (array == null || StoreEntryId.TryParseStoreEntryIdMailboxDN(array) == null)
{
ExTraceGlobals.SharingTracer.TraceError <string, string>((long)this.GetHashCode(), "{0}: SharingRemoteStoreUid is invalid: {1}", messageItem.Session.UserLegacyDN, valueOrDefault7);
throw new InvalidSharingMessageException("SharingRemoteStoreUid");
}
this.context.MailboxId = array;
SharingContextPermissions?valueAsNullable3 = messageItem.GetValueAsNullable <SharingContextPermissions>(InternalSchema.SharingPermissions);
if (valueAsNullable3 != null)
{
this.context.SharingPermissions = valueAsNullable3.Value;
}
SharingContextDetailLevel?valueAsNullable4 = messageItem.GetValueAsNullable <SharingContextDetailLevel>(InternalSchema.SharingDetail);
if (valueAsNullable4 != null)
{
this.context.SharingDetail = valueAsNullable4.Value;
return;
}
if (this.context.DataType == SharingDataType.Calendar)
{
this.context.SharingDetail = SharingContextDetailLevel.FullDetails;
}
}
protected override object InternalTryGetValue(PropertyBag.BasicPropertyStore propertyBag)
{
string valueOrDefault = propertyBag.GetValueOrDefault <string>(InternalSchema.ItemClass, string.Empty);
if (ObjectClass.IsOfClass(valueOrDefault, "IPM.Appointment.Occurrence") || ObjectClass.IsOfClass(valueOrDefault, "IPM.OLE.CLASS.{00061055-0000-0000-C000-000000000046}"))
{
bool valueOrDefault2 = propertyBag.GetValueOrDefault <bool>(InternalSchema.IsException);
if (valueOrDefault2)
{
return(CalendarItemType.Exception);
}
return(CalendarItemType.Occurrence);
}
else
{
bool valueOrDefault3 = propertyBag.GetValueOrDefault <bool>(InternalSchema.AppointmentRecurring);
if (valueOrDefault3)
{
return(CalendarItemType.RecurringMaster);
}
return(CalendarItemType.Single);
}
}
public static bool IsItemLegallyDirty(StoreSession session, CoreItem item, bool verifyLegallyDirty, out List <string> dirtyProperties)
{
dirtyProperties = null;
if (COWSettings.IsCalendarRepairAssistantAction(session))
{
ExTraceGlobals.SessionTracer.TraceWarning <CoreItem>((long)session.GetHashCode(), "Update Item {0} skipped because the action was generated by Calendar Repair Assistant.", item);
return(false);
}
if (item.PropertyBag.GetValueOrDefault <bool>(InternalSchema.IsDraft))
{
ExTraceGlobals.SessionTracer.TraceWarning <CoreItem>((long)session.GetHashCode(), "Update Item {0} skipped because it is a draft.", item);
return(false);
}
if (item.Id == null)
{
ExTraceGlobals.SessionTracer.TraceWarning <CoreItem>((long)session.GetHashCode(), "Update Item {0} skipped because it does not have an id.", item);
return(false);
}
if (item.PropertyBag.GetValueOrDefault <bool>(InternalSchema.IsAssociated))
{
ExTraceGlobals.SessionTracer.TraceWarning <CoreItem>((long)session.GetHashCode(), "Update Item {0} skipped because it is an associated item.", item);
return(false);
}
if (item.Id == null)
{
ExTraceGlobals.SessionTracer.TraceWarning <CoreItem>((long)session.GetHashCode(), "Update Item {0} skipped because the id was null.", item);
return(false);
}
string valueOrDefault = item.PropertyBag.GetValueOrDefault <string>(InternalSchema.ItemClass, string.Empty);
if (ObjectClass.IsOfClass(valueOrDefault, "IPM.Post.RSS"))
{
ExTraceGlobals.SessionTracer.TraceWarning <CoreItem>((long)session.GetHashCode(), "Update Item {0} skipped because it is a RSS item.", item);
return(false);
}
Schema schema = ObjectClass.GetSchema(valueOrDefault);
if (!(schema is ItemSchema))
{
schema = ItemSchema.Instance;
}
bool isLegallyDirty = item.IsLegallyDirty;
CoreRecipientCollection recipients = ((ICoreItem)item).Recipients;
CoreAttachmentCollection attachmentCollection = ((ICoreItem)item).AttachmentCollection;
bool flag = (recipients != null && recipients.IsDirty) || item.IsLegallyDirtyProperty("RecipientCollection");
bool flag2 = (attachmentCollection != null && attachmentCollection.IsDirty) || item.IsLegallyDirtyProperty("AttachmentCollection");
if (!isLegallyDirty && !item.PropertyBag.IsDirty && !flag && !flag2)
{
ExTraceGlobals.SessionTracer.TraceWarning <CoreItem>((long)session.GetHashCode(), "Update Item {0} skipped because the property bag is not dirty.", item);
return(false);
}
StorePropertyDefinition[] array = (from x in schema.LegalTrackingProperties
where item.PropertyBag.IsPropertyDirty(x) || item.IsLegallyDirtyProperty(x.Name)
select x).ToArray <StorePropertyDefinition>();
if (array.Length == 0 && !flag && !flag2)
{
ExTraceGlobals.SessionTracer.TraceWarning <CoreItem>((long)session.GetHashCode(), "Update Item {0} skipped because the property bag is not legally dirty.", item);
return(false);
}
dirtyProperties = new List <string>();
if (!verifyLegallyDirty)
{
dirtyProperties = (from x in array
select x.Name).ToList <string>();
if (flag)
{
dirtyProperties.Add("RecipientCollection");
}
if (flag2)
{
dirtyProperties.Add("AttachmentCollection");
}
}
else
{
using (CoreItem coreItem = CoreItem.Bind(session, item.Id, array))
{
CoreRecipientCollection recipients2 = coreItem.Recipients;
if (flag)
{
flag = false;
int num = (recipients == null) ? 0 : recipients.Count;
int num2 = (recipients2 == null) ? 0 : recipients2.Count;
if (num == num2)
{
if (recipients == null || recipients2 == null)
{
goto IL_36E;
}
using (IEnumerator <CoreRecipient> enumerator = recipients.GetEnumerator())
{
while (enumerator.MoveNext())
{
CoreRecipient value = enumerator.Current;
if (!recipients2.Contains(value, COWDumpster.CoreRecipientParticipantEqualityComparer.Default))
{
flag = true;
break;
}
}
goto IL_36E;
}
}
flag = true;
}
else
{
int num3 = (recipients == null) ? 0 : recipients.Count;
int num4 = (recipients2 == null) ? 0 : recipients2.Count;
flag = (num3 != num4);
}
IL_36E:
if (flag)
{
ExTraceGlobals.SessionTracer.TraceWarning <CoreItem>((long)session.GetHashCode(), "Update Item {0} is dirty because the recipient collection is dirty.", item);
dirtyProperties.Add("RecipientCollection");
}
if (!flag2)
{
CoreAttachmentCollection attachmentCollection2 = coreItem.AttachmentCollection;
int num5 = (attachmentCollection == null) ? 0 : attachmentCollection.Count;
int num6 = (attachmentCollection2 == null) ? 0 : attachmentCollection2.Count;
flag2 = (num5 != num6);
}
if (flag2)
{
ExTraceGlobals.SessionTracer.TraceWarning <CoreItem>((long)session.GetHashCode(), "Update Item {0} is dirty because the attachment collection is dirty.", item);
dirtyProperties.Add("AttachmentCollection");
}
foreach (StorePropertyDefinition propertyDefinition in array)
{
object x2 = item.PropertyBag.TryGetProperty(propertyDefinition);
object y = coreItem.PropertyBag.TryGetProperty(propertyDefinition);
if (!COWDumpster.PropertyValuesAreEqual(propertyDefinition, x2, y))
{
ExTraceGlobals.SessionTracer.TraceWarning <CoreItem, string, PropertyDefinition>((long)session.GetHashCode(), "Update Item {0}, class {1} is dirty because the {2} property is dirty.", item, valueOrDefault, propertyDefinition);
dirtyProperties.Add(propertyDefinition.Name);
}
}
}
}
if (dirtyProperties.Count > 0)
{
ExTraceGlobals.SessionTracer.TraceWarning((long)session.GetHashCode(), "Update Item {0}, class {1} is {2} dirty with {3} properties changed", new object[]
{
item,
valueOrDefault,
verifyLegallyDirty ? "verified" : "not verified",
dirtyProperties.Count
});
return(true);
}
ExTraceGlobals.SessionTracer.TraceWarning <CoreItem, string, int>((long)session.GetHashCode(), "Update Item {0}, class {1} skipped because no legal tracking property was found dirty out of {2} modified legal tracking properties.", item, valueOrDefault, array.Length);
dirtyProperties = null;
return(false);
}
public IEnumerator <IStorePropertyBag> GetEnumerator()
{
ContactFoldersEnumeratorOptions foldersEnumeratorOptions = ContactFoldersEnumeratorOptions.SkipHiddenFolders | ContactFoldersEnumeratorOptions.SkipDeletedFolders | ContactFoldersEnumeratorOptions.IncludeParentFolder;
ContactFoldersEnumerator foldersEnumerator = new ContactFoldersEnumerator(this.session, new XSOFactory(), this.folderType, foldersEnumeratorOptions, new PropertyDefinition[0]);
foreach (IStorePropertyBag folderPropertyBag in foldersEnumerator)
{
VersionedId folderId = folderPropertyBag.GetValueOrDefault <VersionedId>(FolderSchema.Id, null);
IFolder folder;
try
{
folder = this.xsoFactory.BindToFolder(this.session, folderId.ObjectId);
}
catch (ObjectNotFoundException)
{
RecursiveContactsEnumerator.Tracer.TraceError <VersionedId, Guid>((long)this.GetHashCode(), "Failed to bind to folder. FolderId: {0}. Mailbox: {1}.", folderId, this.session.MailboxOwner.MailboxInfo.MailboxGuid);
continue;
}
try
{
using (IQueryResult contactsQuery = folder.IItemQuery(ItemQueryType.None, null, null, this.properties))
{
IStorePropertyBag[] contacts = contactsQuery.GetPropertyBags(100);
while (contacts.Length > 0)
{
foreach (IStorePropertyBag contactPropertyBag in contacts)
{
if (contactPropertyBag != null && !(contactPropertyBag.TryGetProperty(ItemSchema.Id) is PropertyError) && ObjectClass.IsContact(contactPropertyBag.GetValueOrDefault <string>(StoreObjectSchema.ItemClass, null)))
{
yield return(contactPropertyBag);
}
}
contacts = contactsQuery.GetPropertyBags(100);
}
}
}
finally
{
folder.Dispose();
}
}
yield break;
}
public static MessageItem CreateForward(MessageItem originalItem, bool asAttachment, CultureInfo culture, string imceaDomain, string xLoop, ExTimeZone timeZone, IRuleEvaluationContext context)
{
Util.ThrowOnNullArgument(originalItem, "originalItem");
Util.ThrowOnNullArgument(culture, "culture");
Util.ThrowOnNullOrEmptyArgument(imceaDomain, "imceaDomain");
ExTraceGlobals.StorageTracer.Information(0L, "RuleMessageUtils::CreateForward.");
MessageItem messageItem = null;
bool flag = false;
MessageItem result;
try
{
ForwardCreationFlags forwardCreationFlags = ForwardCreationFlags.None;
string className = originalItem.ClassName;
if (ObjectClass.IsMeetingMessage(className))
{
forwardCreationFlags |= ForwardCreationFlags.TreatAsMeetingMessage;
}
messageItem = context.CreateMessageItem(InternalSchema.ContentConversionProperties);
messageItem[InternalSchema.ItemClass] = "IPM.Note";
StoreSession storeSession = context.StoreSession ?? originalItem.Session;
if (asAttachment)
{
ForwardAsAttachmentCreation forwardAsAttachmentCreation = new ForwardAsAttachmentCreation(originalItem, messageItem, new ReplyForwardConfiguration(forwardCreationFlags, culture)
{
XLoop = xLoop,
TimeZone = timeZone,
ConversionOptionsForSmime = new InboundConversionOptions(storeSession.GetADRecipientSession(true, ConsistencyMode.IgnoreInvalid), imceaDomain)
});
forwardAsAttachmentCreation.PopulateProperties();
}
else
{
bool flag2 = ObjectClass.IsMeetingCancellation(className);
bool flag3 = ObjectClass.IsMeetingRequest(className);
bool isRestricted = originalItem.IsRestricted;
if (flag2)
{
messageItem[InternalSchema.ItemClass] = "IPM.Schedule.Meeting.Canceled";
messageItem[InternalSchema.IconIndex] = IconIndex.AppointmentMeetCancel;
}
else if (flag3)
{
messageItem[InternalSchema.ItemClass] = "IPM.Schedule.Meeting.Request";
messageItem[InternalSchema.IsResponseRequested] = true;
messageItem[InternalSchema.IsReplyRequested] = true;
}
else if (isRestricted)
{
messageItem[StoreObjectSchema.ContentClass] = "rpmsg.message";
messageItem.IconIndex = IconIndex.MailIrm;
}
BodyFormat format = originalItem.Body.Format;
ReplyForwardConfiguration replyForwardConfiguration = new ReplyForwardConfiguration(format, forwardCreationFlags, culture);
replyForwardConfiguration.XLoop = xLoop;
replyForwardConfiguration.TimeZone = timeZone;
replyForwardConfiguration.ConversionOptionsForSmime = new InboundConversionOptions(storeSession.GetADRecipientSession(true, ConsistencyMode.IgnoreInvalid), imceaDomain);
RuleMessageUtils.GenerateHeader(replyForwardConfiguration, originalItem);
ForwardCreation forwardCreation = new ForwardCreation(originalItem, messageItem, replyForwardConfiguration);
forwardCreation.PopulateProperties();
if (flag2 || flag3)
{
AppointmentStateFlags appointmentStateFlags = messageItem.GetValueOrDefault <AppointmentStateFlags>(InternalSchema.AppointmentState);
appointmentStateFlags |= (AppointmentStateFlags.Meeting | AppointmentStateFlags.Received);
messageItem[InternalSchema.AppointmentState] = appointmentStateFlags;
int num = messageItem.GetValueOrDefault <int>(InternalSchema.AppointmentAuxiliaryFlags, 0);
num |= 4;
messageItem[InternalSchema.AppointmentAuxiliaryFlags] = num;
if (flag3)
{
List <BlobRecipient> list = BlobRecipientParser.ReadRecipients(originalItem, InternalSchema.UnsendableRecipients);
list = MeetingRequest.FilterBlobRecipientList(list);
list = MeetingRequest.MergeRecipientLists(originalItem.Recipients, list);
list = MeetingRequest.FilterBlobRecipientList(list);
BlobRecipientParser.WriteRecipients(messageItem, InternalSchema.UnsendableRecipients, list);
}
}
}
flag = true;
result = messageItem;
}
finally
{
if (!flag && messageItem != null)
{
messageItem.Dispose();
messageItem = null;
}
}
return(result);
}
private void WriteRecipientTable()
{
if (this.tnefType != TnefType.LegacyTnef || this.isEmbeddedItem)
{
this.tnefWriter.StartAttribute(TnefAttributeTag.RecipientTable, TnefAttributeLevel.Message);
List <ConversionRecipientEntry> recipients = this.addressCache.Recipients;
if (recipients != null)
{
this.conversionResult.RecipientCount = recipients.Count;
foreach (ConversionRecipientEntry conversionRecipientEntry in recipients)
{
if (!(this.item is MessageItem) || this.options.DemoteBcc || conversionRecipientEntry.RecipientItemType != RecipientItemType.Bcc || ((conversionRecipientEntry.Participant.GetValueOrDefault <bool>(ParticipantSchema.IsRoom, false) || conversionRecipientEntry.Participant.GetValueOrDefault <bool>(ParticipantSchema.IsResource, false)) && ObjectClass.IsMeetingMessage(this.item.ClassName)))
{
this.WriteRecipient(conversionRecipientEntry);
}
}
}
}
}
private ConflictResolutionResult ApplyAcr(PropertyBag acrPropBag, SaveMode saveMode)
{
Dictionary <PropertyDefinition, AcrPropertyProfile.ValuesToResolve> valuesToResolve = this.GetValuesToResolve(acrPropBag);
string valueOrDefault = this.PropertyBag.GetValueOrDefault <string>(InternalSchema.ItemClass, string.Empty);
if (ObjectClass.IsCalendarItemCalendarItemOccurrenceOrRecurrenceException(valueOrDefault) || ObjectClass.IsMeetingMessage(valueOrDefault))
{
LocationIdentifierHelper locationIdentifierHelper = new LocationIdentifierHelper();
AcrPropertyProfile.ValuesToResolve valuesToResolve2;
object serverValue;
if (valuesToResolve.TryGetValue(InternalSchema.ChangeList, out valuesToResolve2))
{
locationIdentifierHelper.ChangeBuffer = (byte[])valuesToResolve2.ClientValue;
serverValue = valuesToResolve2.ServerValue;
}
else
{
serverValue = new PropertyError(InternalSchema.ChangeList, PropertyErrorCode.NotFound);
}
locationIdentifierHelper.SetLocationIdentifier(53909U, LastChangeAction.AcrPerformed);
valuesToResolve2 = new AcrPropertyProfile.ValuesToResolve(locationIdentifierHelper.ChangeBuffer, serverValue, null);
valuesToResolve[InternalSchema.ChangeList] = valuesToResolve2;
}
ConflictResolutionResult conflictResolutionResult = this.profile.ResolveConflicts(valuesToResolve);
if (this.propertiesWrittenAsStream.Count > 0)
{
List <PropertyConflict> list = new List <PropertyConflict>(conflictResolutionResult.PropertyConflicts);
foreach (PropertyDefinition propertyDefinition in this.propertiesWrittenAsStream.Keys)
{
PropertyConflict item = new PropertyConflict(propertyDefinition, null, null, null, null, false);
list.Add(item);
}
conflictResolutionResult = new ConflictResolutionResult(SaveResult.IrresolvableConflict, list.ToArray());
}
if (this.irresolvableChanges || saveMode == SaveMode.FailOnAnyConflict)
{
conflictResolutionResult = new ConflictResolutionResult(SaveResult.IrresolvableConflict, conflictResolutionResult.PropertyConflicts);
}
if (conflictResolutionResult.SaveStatus != SaveResult.IrresolvableConflict)
{
List <PropertyDefinition> list2 = new List <PropertyDefinition>();
List <PropertyDefinition> list3 = new List <PropertyDefinition>();
List <object> list4 = new List <object>();
if (this.propertyBag == acrPropBag)
{
foreach (PropertyConflict propertyConflict in conflictResolutionResult.PropertyConflicts)
{
if (propertyConflict.ResolvedValue is PropertyError)
{
if (PropertyError.IsPropertyNotFound(propertyConflict.ResolvedValue) && (!PropertyError.IsPropertyError(propertyConflict.ClientValue) || !PropertyError.IsPropertyNotFound(propertyConflict.ClientValue)))
{
list2.Add(propertyConflict.PropertyDefinition);
}
}
else if (propertyConflict.ResolvedValue != propertyConflict.ClientValue)
{
list3.Add(propertyConflict.PropertyDefinition);
list4.Add(propertyConflict.ResolvedValue);
}
}
}
else
{
foreach (PropertyConflict propertyConflict2 in conflictResolutionResult.PropertyConflicts)
{
if (propertyConflict2.ResolvedValue is PropertyError)
{
if (PropertyError.IsPropertyNotFound(propertyConflict2.ResolvedValue))
{
list2.Add(propertyConflict2.PropertyDefinition);
}
}
else if (propertyConflict2.ServerValue != propertyConflict2.ResolvedValue)
{
list3.Add(propertyConflict2.PropertyDefinition);
list4.Add(propertyConflict2.ResolvedValue);
}
}
}
for (int k = 0; k < list2.Count; k++)
{
acrPropBag.Delete(list2[k]);
}
for (int l = 0; l < list3.Count; l++)
{
acrPropBag[list3[l]] = list4[l];
}
}
return(conflictResolutionResult);
}
public static void CreateForwardReplyHeader(ReplyForwardConfiguration configuration, Item item, ForwardReplyHeaderOptions headerOptions = null)
{
if (!(item is MessageItem) && !(item is CalendarItemBase) && !(item is PostItem))
{
throw new ArgumentException("HTML reply forward headers can only be created for MessageItem, CalendarItemBase and PostItem");
}
if (headerOptions == null)
{
headerOptions = new ForwardReplyHeaderOptions();
}
CultureInfo cultureInfo = configuration.Culture ?? item.Session.InternalCulture;
if (item is PostItem)
{
ReplyForwardHeader.CreatePostReplyForwardHeader(configuration, item, headerOptions, cultureInfo);
}
IList <IRecipientBase> toRecipients = null;
IList <IRecipientBase> ccRecipients = null;
string from = string.Empty;
string sender = null;
string fromLabel = ClientStrings.FromColon.ToString(cultureInfo);
string toLabel = ClientStrings.ToColon.ToString(cultureInfo);
string ccLabel = ClientStrings.CcColon.ToString(cultureInfo);
bool isMeetingItem = ObjectClass.IsMeetingMessage(item.ClassName);
if (item is MessageItem)
{
MessageItem messageItem = (MessageItem)item;
if (messageItem.From != null)
{
from = messageItem.From.DisplayName;
}
if (messageItem.Sender != null)
{
sender = messageItem.Sender.DisplayName;
}
toRecipients = ReplyForwardHeader.GetMessageRecipientCollection(RecipientItemType.To, messageItem);
ccRecipients = ReplyForwardHeader.GetMessageRecipientCollection(RecipientItemType.Cc, messageItem);
}
else if (item is CalendarItemBase)
{
CalendarItemBase calendarItemBase = (CalendarItemBase)item;
if (calendarItemBase.Organizer != null)
{
from = calendarItemBase.Organizer.DisplayName;
}
toRecipients = ReplyForwardHeader.GetCalendarItemRecipientCollection(AttendeeType.Required, calendarItemBase);
ccRecipients = ReplyForwardHeader.GetCalendarItemRecipientCollection(AttendeeType.Optional, calendarItemBase);
}
BodyInjectionFormat bodyPrefixFormat;
string bodyPrefix;
switch (configuration.TargetFormat)
{
case BodyFormat.TextPlain:
bodyPrefixFormat = BodyInjectionFormat.Text;
bodyPrefix = ReplyForwardHeader.CreateTextReplyForwardHeader(item, headerOptions, fromLabel, from, sender, toLabel, ccLabel, toRecipients, ccRecipients, isMeetingItem, cultureInfo, configuration.TimeZone);
break;
case BodyFormat.TextHtml:
case BodyFormat.ApplicationRtf:
bodyPrefixFormat = BodyInjectionFormat.Html;
bodyPrefix = ReplyForwardHeader.CreateHtmlReplyForwardHeader(item, headerOptions, fromLabel, from, sender, toLabel, ccLabel, toRecipients, ccRecipients, isMeetingItem, cultureInfo, configuration.TimeZone);
break;
default:
throw new ArgumentException("Unsupported body format");
}
configuration.AddBodyPrefix(bodyPrefix, bodyPrefixFormat);
}
private void CopyMeetingRequestProperties(CalendarItemBase calendarItem, bool preserveLocalExceptions)
{
long size = calendarItem.Body.Size;
calendarItem.LocationIdentifierHelperInstance.SetLocationIdentifier(42101U);
if (!base.IsRepairUpdateMessage || (this.ChangeHighlight & ChangeHighlightProperties.BodyProps) == ChangeHighlightProperties.BodyProps)
{
Body.CopyBody(this, calendarItem, false);
this.CopyNlgPropertiesTo(calendarItem);
}
ChangeHighlightProperties changeHighlight = this.ChangeHighlight;
this.ProcessChangeHighlights(calendarItem, calendarItem.Body.Size, size);
MeetingMessageType meetingMessageType = base.GetValueOrDefault <MeetingMessageType>(InternalSchema.MeetingRequestType, MeetingMessageType.NewMeetingRequest);
if (meetingMessageType == MeetingMessageType.PrincipalWantsCopy)
{
if (calendarItem.IsNew)
{
meetingMessageType = MeetingMessageType.NewMeetingRequest;
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId>((long)this.GetHashCode(), "Storage.MeetingRequest.CopyMeetingRequestProperties: GOID={0}; Meeting type is PrincipalWantsCopy and calendar item just created.", this.GlobalObjectId);
}
else
{
meetingMessageType = base.GetValueOrDefault <MeetingMessageType>(InternalSchema.OriginalMeetingType, MeetingMessageType.NewMeetingRequest);
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId, MeetingMessageType>((long)this.GetHashCode(), "Storage.MeetingRequest.CopyMeetingRequestProperties: GOID={0}; Meeting type is PrincipalWantsCopy. Will use OriginalMeetingType {1}", this.GlobalObjectId, meetingMessageType);
}
}
base.LocationIdentifierHelperInstance.SetLocationIdentifier(60533U, LastChangeAction.CopyMeetingRequestProperties);
calendarItem.LocationIdentifierHelperInstance.SetLocationIdentifier(35957U, LastChangeAction.CopyMeetingRequestProperties);
if (MeetingMessageType.NewMeetingRequest == meetingMessageType || calendarItem.IsNew)
{
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId, string>((long)this.GetHashCode(), "Storage.MeetingRequest.CopyMeetingRequestProperties: GOID={0}; {1}", this.GlobalObjectId, "Copying WriteOnCreate properties onto calendar item.");
calendarItem.LocationIdentifierHelperInstance.SetLocationIdentifier(52341U);
CalendarItemBase.CopyPropertiesTo(this, calendarItem, MeetingMessage.WriteOnCreateProperties);
if (base.IsSeriesMessage)
{
CalendarItemBase.CopyPropertiesTo(this, calendarItem, MeetingMessage.WriteOnCreateSeriesProperties);
}
Reminder.EnsureMinutesBeforeStartIsInRange(calendarItem, this.consumerDefaultMinutesBeforeStart);
if (base.IsRepairUpdateMessage)
{
int?valueAsNullable = base.GetValueAsNullable <int>(CalendarItemBaseSchema.ItemVersion);
if (valueAsNullable != null)
{
calendarItem[CalendarItemBaseSchema.ItemVersion] = valueAsNullable;
}
}
}
if (meetingMessageType == MeetingMessageType.NewMeetingRequest || (!base.IsRepairUpdateMessage && meetingMessageType == MeetingMessageType.FullUpdate))
{
calendarItem.ResponseType = ResponseType.NotResponded;
BusyType valueOrDefault = base.GetValueOrDefault <BusyType>(InternalSchema.IntendedFreeBusyStatus, BusyType.Busy);
BusyType valueOrDefault2 = base.GetValueOrDefault <BusyType>(InternalSchema.FreeBusyStatus, BusyType.Tentative);
calendarItem.LocationIdentifierHelperInstance.SetLocationIdentifier(58485U);
calendarItem[InternalSchema.IntendedFreeBusyStatus] = valueOrDefault;
calendarItem[InternalSchema.FreeBusyStatus] = ((valueOrDefault != BusyType.Free) ? valueOrDefault2 : BusyType.Free);
}
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId, string>((long)this.GetHashCode(), "Storage.MeetingRequest.CopyMeetingRequestProperties: GOID={0}; {1}", this.GlobalObjectId, "Copying properties onto calendar item.");
byte[] largeBinaryProperty = base.PropertyBag.GetLargeBinaryProperty(InternalSchema.AppointmentRecurrenceBlob);
CalendarItem calendarItem2 = calendarItem as CalendarItem;
bool flag = false;
if (largeBinaryProperty != null && calendarItem2 != null)
{
calendarItem2.SuppressUpdateRecurrenceTimeOffset = true;
this.CopyRecurrenceBlob(calendarItem2, largeBinaryProperty, preserveLocalExceptions);
flag = true;
}
else if (calendarItem.CalendarItemType == CalendarItemType.RecurringMaster)
{
CalendarItem calendarItem3 = calendarItem as CalendarItem;
if (calendarItem3 != null)
{
calendarItem3.Recurrence = null;
}
}
calendarItem.LocationIdentifierHelperInstance.SetLocationIdentifier(62581U);
if (calendarItem is CalendarItem)
{
PropertyChangeMetadataProcessingFlags propertyChangeMetadataProcessingFlags = calendarItem.GetValueOrDefault <PropertyChangeMetadataProcessingFlags>(CalendarItemSchema.PropertyChangeMetadataProcessingFlags, PropertyChangeMetadataProcessingFlags.None);
propertyChangeMetadataProcessingFlags |= PropertyChangeMetadataProcessingFlags.OverrideMetadata;
calendarItem[CalendarItemSchema.PropertyChangeMetadataProcessingFlags] = propertyChangeMetadataProcessingFlags;
}
if (this.ShouldPreserveAttendeesChanges(calendarItem))
{
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId, string>((long)this.GetHashCode(), "Storage.MeetingRequest.CopyMeetingRequestProperties: GOID={0}; {1}", this.GlobalObjectId, "Will copy properties trying to preserve attendee's changes.");
CalendarItemBase.CopyPropertiesTo(this, calendarItem, CalendarItemProperties.NonPreservableMeetingMessageProperties);
PreservableMeetingMessageProperty.CopyPreserving(new PreservablePropertyContext(this, calendarItem, changeHighlight));
if (calendarItem is CalendarItem)
{
PropertyChangeMetadata valueOrDefault3 = calendarItem.GetValueOrDefault <PropertyChangeMetadata>(InternalSchema.PropertyChangeMetadata);
PropertyChangeMetadata valueOrDefault4 = base.GetValueOrDefault <PropertyChangeMetadata>(InternalSchema.PropertyChangeMetadata);
PropertyChangeMetadata propertyChangeMetadata = PropertyChangeMetadata.Merge(valueOrDefault3, valueOrDefault4);
if (propertyChangeMetadata != null)
{
calendarItem[InternalSchema.PropertyChangeMetadata] = propertyChangeMetadata;
}
}
}
else
{
if (calendarItem.CalendarItemType == CalendarItemType.RecurringMaster || calendarItem.CalendarItemType == CalendarItemType.Single)
{
calendarItem.DeleteProperties(MeetingMessage.DisplayTimeZoneProperties);
}
if (calendarItem is CalendarItem)
{
CalendarItemBase.CopyPropertiesTo(this, calendarItem, new PropertyDefinition[]
{
InternalSchema.PropertyChangeMetadataRaw
});
}
CalendarItemBase.CopyPropertiesTo(this, calendarItem, MeetingMessage.MeetingMessageProperties);
}
string valueOrDefault5 = base.GetValueOrDefault <string>(InternalSchema.AppointmentClass);
if (valueOrDefault5 != null && ObjectClass.IsDerivedClass(valueOrDefault5, "IPM.Appointment"))
{
calendarItem.ClassName = valueOrDefault5;
}
Microsoft.Exchange.Data.Storage.Item.CopyCustomPublicStrings(this, calendarItem);
calendarItem.LocationIdentifierHelperInstance.SetLocationIdentifier(54389U);
CalendarItemBase.CopyPropertiesTo(this, calendarItem, new PropertyDefinition[]
{
InternalSchema.TimeZoneDefinitionRecurring
});
if (meetingMessageType == MeetingMessageType.InformationalUpdate && !calendarItem.IsCalendarItemTypeOccurrenceOrException)
{
Sensitivity?valueAsNullable2 = base.GetValueAsNullable <Sensitivity>(InternalSchema.Sensitivity);
if (valueAsNullable2 != null && calendarItem.Sensitivity != Sensitivity.Private && Enum.IsDefined(typeof(Sensitivity), valueAsNullable2.Value))
{
calendarItem.Sensitivity = valueAsNullable2.Value;
}
}
calendarItem.LocationIdentifierHelperInstance.SetLocationIdentifier(50293U);
calendarItem.Reminder.Adjust();
if (flag && calendarItem2 != null)
{
calendarItem2.ReloadRecurrence();
}
}
private COWProcessorState InspectNotification(COWTriggerAction operation, StoreSession session, CoreItem item, bool onBeforeNotification, bool onDumpster)
{
if (onDumpster)
{
return(COWProcessorState.DoNotProcess);
}
if (operation != COWTriggerAction.Create)
{
COWGroupMessageWSPublishing.Tracer.TraceDebug((long)this.GetHashCode(), "COWGroupMessageWSPublishing.InspectNotification: not an Create operation.");
return(COWProcessorState.DoNotProcess);
}
if (!onBeforeNotification)
{
return(COWProcessorState.DoNotProcess);
}
if (item == null)
{
return(COWProcessorState.Unknown);
}
if (item.Id != null)
{
COWGroupMessageWSPublishing.Tracer.TraceDebug((long)this.GetHashCode(), "COWGroupMessageWSPublishing.InspectNotification: ItemId is non-null, so this is not a new item. Do not process.");
return(COWProcessorState.DoNotProcess);
}
MailboxSession mailboxSession = session as MailboxSession;
if (mailboxSession == null)
{
COWGroupMessageWSPublishing.Tracer.TraceDebug((long)this.GetHashCode(), "COWGroupMessageWSPublishing.InspectNotification: not a mailbox session. Do not process.");
return(COWProcessorState.DoNotProcess);
}
int?num = mailboxSession.Mailbox.TryGetProperty(MailboxSchema.MailboxTypeDetail) as int?;
if (num == null)
{
COWGroupMessageWSPublishing.Tracer.TraceDebug((long)this.GetHashCode(), "COWGroupMessageWSPublishing.InspectNotification: mailbox type not found. Try to inspect later.");
return(COWProcessorState.Unknown);
}
if (!StoreSession.IsGroupMailbox(num.Value))
{
COWGroupMessageWSPublishing.Tracer.TraceDebug((long)this.GetHashCode(), "COWGroupMessageWSPublishing.InspectNotification: Mailbox isn't a GroupMailbox. Do not process.");
return(COWProcessorState.DoNotProcess);
}
string valueOrDefault = item.PropertyBag.GetValueOrDefault <string>(StoreObjectSchema.ItemClass, string.Empty);
if (string.IsNullOrEmpty(valueOrDefault))
{
COWGroupMessageWSPublishing.Tracer.TraceDebug((long)this.GetHashCode(), "COWGroupMessageWSPublishing.InspectNotification: item class not found. Try to inspect later.");
return(COWProcessorState.Unknown);
}
if (!ObjectClass.IsMessage(valueOrDefault, false))
{
COWGroupMessageWSPublishing.Tracer.TraceDebug((long)this.GetHashCode(), "COWGroupMessageWSPublishing.InspectNotification: item class is not a message. Do not process.");
return(COWProcessorState.DoNotProcess);
}
if (ObjectClass.IsMeetingForwardNotification(valueOrDefault))
{
COWGroupMessageWSPublishing.Tracer.TraceDebug((long)this.GetHashCode(), "COWGroupMessageWSPublishing.InspectNotification: item class is meeting forward notification. Do not process.");
return(COWProcessorState.DoNotProcess);
}
if (ObjectClass.IsMeetingResponse(valueOrDefault))
{
COWGroupMessageWSPublishing.Tracer.TraceDebug((long)this.GetHashCode(), "COWGroupMessageWSPublishing.InspectNotification: item class is meeting response. Do not process.");
return(COWProcessorState.DoNotProcess);
}
bool flag = ClientInfo.OWA.IsMatch(mailboxSession.ClientInfoString);
bool flag2 = ClientInfo.HubTransport.IsMatch(mailboxSession.ClientInfoString);
if (!flag && !flag2)
{
COWGroupMessageWSPublishing.Tracer.TraceDebug((long)this.GetHashCode(), "COWGroupMessageWSPublishing.InspectNotification: This isn't either a post or a delivery. Do not process.");
return(COWProcessorState.DoNotProcess);
}
StoreObjectId storeObjectId = item.PropertyBag.TryGetProperty(StoreObjectSchema.ParentItemId) as StoreObjectId;
if (storeObjectId == null)
{
COWGroupMessageWSPublishing.Tracer.TraceDebug((long)this.GetHashCode(), "COWGroupMessageWSPublishing.InspectNotification: parent folder id not found. Try to inspect later.");
return(COWProcessorState.Unknown);
}
StoreObjectId defaultFolderId = mailboxSession.GetDefaultFolderId(DefaultFolderType.Inbox);
if (defaultFolderId == null)
{
COWGroupMessageWSPublishing.Tracer.TraceDebug((long)this.GetHashCode(), "COWGroupMessageWSPublishing.InspectNotification: inbox folder id not found. Try to inspect later.");
return(COWProcessorState.Unknown);
}
if (!storeObjectId.Equals(defaultFolderId))
{
COWGroupMessageWSPublishing.Tracer.TraceDebug((long)this.GetHashCode(), "COWGroupMessageWSPublishing.InspectNotification: This message isn't located on the inbox folder. Do not process.");
return(COWProcessorState.DoNotProcess);
}
return(COWProcessorState.ProcessAfterSave);
}
internal override StoreObjectValidationError Validate(ValidationContext context, IValidatablePropertyBag validatablePropertyBag)
{
string text = validatablePropertyBag.TryGetProperty(InternalSchema.ItemClass) as string;
if (!string.IsNullOrEmpty(text) && (ObjectClass.IsCalendarItem(text) || ObjectClass.IsRecurrenceException(text) || ObjectClass.IsMeetingMessage(text)) && validatablePropertyBag.IsPropertyDirty(InternalSchema.AppointmentStateInternal))
{
object obj = validatablePropertyBag.TryGetProperty(InternalSchema.AppointmentStateInternal);
if (obj is int)
{
AppointmentStateFlags appointmentStateFlags = (AppointmentStateFlags)obj;
if (EnumValidator <AppointmentStateFlags> .IsValidValue(appointmentStateFlags))
{
PropertyValueTrackingData originalPropertyInformation = validatablePropertyBag.GetOriginalPropertyInformation(InternalSchema.AppointmentStateInternal);
if (originalPropertyInformation.PropertyValueState == PropertyTrackingInformation.Modified && originalPropertyInformation.OriginalPropertyValue != null && !PropertyError.IsPropertyNotFound(originalPropertyInformation.OriginalPropertyValue))
{
AppointmentStateFlags appointmentStateFlags2 = (AppointmentStateFlags)originalPropertyInformation.OriginalPropertyValue;
bool flag = (appointmentStateFlags2 & AppointmentStateFlags.Received) == AppointmentStateFlags.None;
bool flag2 = (appointmentStateFlags & AppointmentStateFlags.Received) == AppointmentStateFlags.None;
if (flag != flag2)
{
return(new StoreObjectValidationError(context, InternalSchema.AppointmentStateInternal, obj, this));
}
}
}
}
}
return(null);
}
private static Charset GetItemOutboundMimeCharsetInternal(Item item, OutboundConversionOptions options)
{
object obj = item.TryGetProperty(InternalSchema.InternetCpid);
bool valueOrDefault = item.GetValueOrDefault <bool>(InternalSchema.IsAutoForwarded, false);
string className = item.ClassName;
Charset charset = null;
if (valueOrDefault || (obj is PropertyError && !item.Body.IsBodyDefined) || (options != null && options.DetectionOptions.PreferredCharset != null && (options.DetectionOptions.RequiredCoverage < 100 || ObjectClass.IsTaskRequest(className) || ObjectClass.IsMeetingMessage(className))))
{
charset = ConvertUtils.DetectOutboundCharset(item, options, obj, !valueOrDefault);
if (charset != null)
{
if (!item.CharsetDetector.IsItemCharsetKnownWithoutDetection(BodyCharsetFlags.DisableCharsetDetection, charset, out charset))
{
throw new InvalidOperationException();
}
return(charset);
}
}
if (!(obj is PropertyError) && Charset.TryGetCharset((int)obj, out charset) && ConvertUtils.TryTransformCharset(ref charset))
{
return(charset);
}
object obj2 = item.TryGetProperty(InternalSchema.Codepage);
if (!(obj2 is PropertyError) && Charset.TryGetCharset((int)obj2, out charset))
{
charset = charset.Culture.MimeCharset;
if (ConvertUtils.TryTransformCharset(ref charset))
{
return(charset);
}
}
return(Charset.GetCharset(65001));
}
public ManifestCallbackStatus Change(byte[] entryId, byte[] sourceKey, byte[] changeKey, byte[] changeList, DateTime lastModifiedTime, ManifestChangeType changeType, bool associated, PropValue[] properties)
{
EnumValidator.ThrowIfInvalid <ManifestChangeType>(changeType, "changeType");
if (ExTraceGlobals.SyncTracer.IsTraceEnabled(TraceType.InfoTrace))
{
this.TraceChangeChangeCallbackProps(entryId, sourceKey, changeKey, changeList, lastModifiedTime, changeType, associated, properties);
}
int? num = null;
string text = null;
bool read = false;
ConversationId conversationId = null;
bool firstMessageInConversation = false;
ExDateTime? filterDate = null;
foreach (PropValue propValue in properties)
{
if (!propValue.IsError())
{
PropTag propTag = propValue.PropTag;
if (propTag <= PropTag.MessageDeliveryTime)
{
if (propTag != PropTag.MessageClass)
{
ConversationIndex index;
if (propTag != PropTag.ConversationIndex)
{
if (propTag == PropTag.MessageDeliveryTime)
{
if (propValue.PropType == PropType.SysTime)
{
filterDate = new ExDateTime?((ExDateTime)propValue.GetDateTime());
}
}
}
else if (propValue.PropType == PropType.Binary && ConversationIndex.TryCreate(propValue.GetBytes(), out index) && index != ConversationIndex.Empty && index.Components != null && index.Components.Count == 1)
{
firstMessageInConversation = true;
}
}
else if (propValue.PropType == PropType.String)
{
text = propValue.GetString();
}
}
else if (propTag != PropTag.MessageFlags)
{
if (propTag != PropTag.InternetArticleNumber)
{
if (propTag == PropTag.ConversationId)
{
if (propValue.PropType == PropType.Binary)
{
conversationId = ConversationId.Create(propValue.GetBytes());
}
}
}
else
{
if (propValue.PropType != PropType.Int)
{
return(ManifestCallbackStatus.Continue);
}
num = new int?(propValue.GetInt());
}
}
else if (propValue.PropType == PropType.Int)
{
MessageFlags @int = (MessageFlags)propValue.GetInt();
read = ((@int & MessageFlags.IsRead) == MessageFlags.IsRead);
}
}
}
if (changeType == ManifestChangeType.Add || changeType == ManifestChangeType.Change)
{
if (num == null)
{
return(ManifestCallbackStatus.Continue);
}
StoreObjectId id = StoreObjectId.FromProviderSpecificId(entryId, (text == null) ? StoreObjectType.Unknown : ObjectClass.GetObjectType(text));
MailboxSyncItemId mailboxSyncItemId = MailboxSyncItemId.CreateForNewItem(id);
MailboxSyncWatermark mailboxSyncWatermark = MailboxSyncWatermark.CreateForSingleItem();
mailboxSyncWatermark.UpdateWithChangeNumber(num.Value, read);
ServerManifestEntry serverManifestEntry = this.mailboxSyncProvider.CreateItemChangeManifestEntry(mailboxSyncItemId, mailboxSyncWatermark);
serverManifestEntry.IsNew = (changeType == ManifestChangeType.Add);
serverManifestEntry.MessageClass = text;
serverManifestEntry.ConversationId = conversationId;
serverManifestEntry.FirstMessageInConversation = firstMessageInConversation;
serverManifestEntry.FilterDate = filterDate;
mailboxSyncItemId.ChangeKey = changeKey;
this.lastServerManifestEntry = serverManifestEntry;
}
else
{
StoreObjectId id2 = StoreObjectId.FromProviderSpecificId(entryId, StoreObjectType.Unknown);
MailboxSyncItemId mailboxSyncItemId2 = MailboxSyncItemId.CreateForExistingItem(this.mailboxSyncProvider.FolderSync, id2);
if (mailboxSyncItemId2 == null)
{
return(ManifestCallbackStatus.Continue);
}
this.lastServerManifestEntry = MailboxSyncProvider.CreateItemDeleteManifestEntry(mailboxSyncItemId2);
this.lastServerManifestEntry.ConversationId = conversationId;
}
return(this.CheckYieldOrStop());
}
protected override void OnBeforeSave()
{
if (this.decodedItem == null && !base.AttachmentCollection.IsDirty && base.IsRestricted && (base.Recipients.IsDirty || base.IsPropertyDirty(ItemSchema.Sender)))
{
this.EnsureIsDecoded();
}
if (this.decodedItem != null)
{
string contentClass = base.TryGetProperty(InternalSchema.ContentClass) as string;
if (this.rmsTemplate == null)
{
this.UnprotectAllAttachments();
RightsManagedMessageItem.CopyProtectableData(this.decodedItem, this);
if (ObjectClass.IsRightsManagedContentClass(contentClass))
{
base.Delete(StoreObjectSchema.ContentClass);
}
}
else
{
this.charsetDetectionStringForProtectedData = new StringBuilder((int)Math.Min(this.ProtectedBody.Size, 2147483647L));
this.GetCharsetDetectionStringFromProtectedData(this.charsetDetectionStringForProtectedData);
if (!ObjectClass.IsRightsManagedContentClass(contentClass))
{
this[StoreObjectSchema.ContentClass] = "rpmsg.message";
}
if (this.isSending)
{
byte[][] valueOrDefault = base.GetValueOrDefault <byte[][]>(InternalSchema.DRMLicense);
if (valueOrDefault != null && valueOrDefault.Length == RightsManagedMessageItem.EmptyDrmLicense.Length && valueOrDefault[0].Length == RightsManagedMessageItem.EmptyDrmLicense[0].Length)
{
base.DeleteProperties(new PropertyDefinition[]
{
InternalSchema.DRMLicense
});
}
}
else if (base.IsDraft && base.GetValueOrDefault <byte[][]>(InternalSchema.DRMLicense) == null)
{
this[InternalSchema.DRMLicense] = RightsManagedMessageItem.EmptyDrmLicense;
}
base.AttachmentCollection.RemoveAll();
using (StreamAttachment streamAttachment = base.AttachmentCollection.Create(AttachmentType.Stream) as StreamAttachment)
{
streamAttachment.FileName = "message.rpmsg";
streamAttachment.ContentType = "application/x-microsoft-rpmsg-message";
using (Stream stream = new PooledMemoryStream(131072))
{
if (this.serverUseLicense == null || ((this.UsageRights & ContentRight.Owner) == ContentRight.Owner && this.rmsTemplate.RequiresRepublishingWhenRecipientsChange && this.CanRepublish && (base.Recipients.IsDirty || (base.IsPropertyDirty(ItemSchema.Sender) && this.conversationOwner == null))))
{
if (this.ConversationOwner == null)
{
throw new InvalidOperationException("Conversation owner must be set before protecting the message.");
}
this.UnprotectAllAttachments();
using (MsgToRpMsgConverter msgToRpMsgConverter = new MsgToRpMsgConverter(this, this.ConversationOwner, this.orgId, this.rmsTemplate, this.options))
{
msgToRpMsgConverter.Convert(this.decodedItem, stream);
using (Stream stream2 = base.OpenPropertyStream(MessageItemSchema.DRMServerLicenseCompressed, PropertyOpenMode.Create))
{
DrmEmailCompression.CompressUseLicense(msgToRpMsgConverter.ServerUseLicense, stream2);
}
if (this.InternalSession != null && this.InternalSession.MailboxOwner.Sid != null)
{
ExDateTime useLicenseExpiryTime = RmsClientManagerUtils.GetUseLicenseExpiryTime(msgToRpMsgConverter.ServerUseLicense, this.UsageRights);
this[MessageItemSchema.DRMRights] = (int)this.UsageRights;
this[MessageItemSchema.DRMExpiryTime] = useLicenseExpiryTime;
using (RightsSignatureBuilder rightsSignatureBuilder = new RightsSignatureBuilder(msgToRpMsgConverter.ServerUseLicense, msgToRpMsgConverter.PublishLicense, RmsClientManager.EnvironmentHandle, msgToRpMsgConverter.LicensePair))
{
this[MessageItemSchema.DRMPropsSignature] = rightsSignatureBuilder.Sign(this.UsageRights, useLicenseExpiryTime, this.InternalSession.MailboxOwner.Sid);
}
}
goto IL_362;
}
}
using (MsgToRpMsgConverter msgToRpMsgConverter2 = new MsgToRpMsgConverter(this, this.orgId, this.publishLicense, this.serverUseLicense, this.options))
{
msgToRpMsgConverter2.Convert(this.decodedItem, stream);
}
IL_362:
using (Stream contentStream = streamAttachment.GetContentStream(PropertyOpenMode.Create))
{
stream.Seek(0L, SeekOrigin.Begin);
Util.StreamHandler.CopyStreamData(stream, contentStream);
}
}
bool flag = false;
foreach (AttachmentHandle handle in this.decodedItem.AttachmentCollection)
{
if (!CoreAttachmentCollection.IsInlineAttachment(handle))
{
flag = true;
break;
}
}
this[InternalSchema.AllAttachmentsHidden] = !flag;
streamAttachment.Save();
}
}
this.decodedItem.Dispose();
this.decodedItem = null;
this.effectiveRights = ContentRight.Owner;
this.publishLicense = null;
this.restrictionInfo = null;
this.rmsTemplate = null;
this.serverUseLicense = null;
this.conversationOwner = null;
}
base.OnBeforeSave();
}
public void MoveNext()
{
this.CheckDisposed("MoveNext");
for (;;)
{
this.currentRow++;
if (this.rows == null || this.currentRow >= this.rows.Length)
{
this.currentRow = 0;
this.rows = this.query.GetPropertyBags(this.chunkSize);
if (this.rows.Length == 0)
{
break;
}
this.chunkSize = Math.Min(this.chunkSize * 2, 1000);
}
IStorePropertyBag storePropertyBag = this.Current;
object obj = storePropertyBag.TryGetProperty(StoreObjectSchema.ItemClass);
if (storePropertyBag != null && !(storePropertyBag.TryGetProperty(ItemSchema.Id) is PropertyError) && !(obj is PropertyError) && (ObjectClass.IsContact((string)obj) || ObjectClass.IsDistributionList((string)obj)))
{
return;
}
AllContactsCursor.Tracer.TraceDebug(0L, "AllContactsCursor.MoveNext: Skipping bogus contact");
}
this.rows = null;
}
