/// <summary>
/// Initializes a new instance of the FolderEntryID class.
/// </summary>
/// <param name="objectType">Identify store object is a mailbox or a public folder.</param>
public FolderEntryID(StoreObjectType objectType)
{
if (objectType == StoreObjectType.Mailbox)
{
this.folderType = new byte[] { 0x01, 0x00 };
}
else
{
this.folderType = new byte[] { 0x03, 0x00 };
}
}
/// <summary>
/// Initializes a new instance of the FolderEntryID class.
/// </summary>
/// <param name="objectType">Identify store object is a mailbox or a public folder.</param>
/// <param name="providerUID">Provider id value which can get in logon response.</param>
/// <param name="databaseGUID">DatabaseGUID of specific folder, which can get in folder's longterm id.</param>
/// <param name="globalCounter">Global counter of specific folder, which can get in folder's longterm id.</param>
public FolderEntryID(StoreObjectType objectType, byte[] providerUID, byte[] databaseGUID, byte[] globalCounter)
{
this.providerUID = providerUID;
this.dataBaseGUID = databaseGUID;
this.globalCounter = globalCounter;
if (objectType == StoreObjectType.Mailbox)
{
this.folderType = new byte[] { 0x01, 0x00 };
}
else
{
this.folderType = new byte[] { 0x03, 0x00 };
}
}
/// <summary>
/// Initializes a new instance of the StoreObjectEntryID class.
/// </summary>
public StoreObjectEntryID()
{
this.objectType = StoreObjectType.Mailbox;
}
/// <summary>
/// Deserialized byte array to an ActionBlock instance
/// </summary>
/// <param name="buffer">Byte array contain data of an ActionBlock instance.</param>
/// <returns>Bytes count that deserialized in buffer.</returns>
public uint Deserialize(byte[] buffer)
{
BufferReader reader = new BufferReader(buffer);
uint flags = reader.ReadUInt32();
if (this.Flags != flags)
{
string errorMessage = "Flags MUST be 0x00000000, the actual value is " + flags.ToString() + "!";
throw new ArgumentException(errorMessage);
}
byte[] providerUID = reader.ReadBytes(16);
if (!Common.CompareByteArray(this.ProviderUID, providerUID))
{
string errorMessage = "ProviderUID MUST be %x38.A1.BB.10.05.E5.10.1A.A1.BB.08.00.2B.2A.56.C2., the actual value is " + providerUID.ToString() + "!";
throw new ArgumentException(errorMessage);
}
byte version = reader.ReadByte();
if (this.Version != version)
{
string errorMessage = "Version MUST be zero., the actual value is " + version.ToString() + "!";
throw new ArgumentException(errorMessage);
}
byte flag = reader.ReadByte();
if (this.Flag != flag)
{
string errorMessage = "Flag MUST be zero, the actual value is " + flag.ToString() + "!";
throw new ArgumentException(errorMessage);
}
byte[] dllFileName = reader.ReadBytes(14);
if (!Common.CompareByteArray(this.DLLFileName, dllFileName))
{
string errorMessage = "DLLFileName MUST be set to the following value which represents \"emsmdb.dll\": %x45.4D.53.4D.44.42.2E.44.4C.4C.00.00.00.00., the actual value is " + dllFileName.ToString() + "!";
throw new ArgumentException(errorMessage);
}
uint wrappedFlags = reader.ReadUInt32();
if (this.WrappedFlags != wrappedFlags)
{
string errorMessage = "WrappedFlags MUST be 0x00000000, the actual value is " + wrappedFlags.ToString() + "!";
throw new ArgumentException(errorMessage);
}
byte[] wrappedProviderUID = reader.ReadBytes(16);
if (Common.CompareByteArray(this.mailboxWrappedProviderUID, wrappedProviderUID))
{
this.objectType = StoreObjectType.Mailbox;
}
else if (Common.CompareByteArray(this.publicFolderWrappedProviderUID, wrappedProviderUID))
{
this.objectType = StoreObjectType.PublicFolder;
}
else
{
string errorMessage = "WrappedProviderUID is not mailbox or public folder, the actual wrappedProviderUID value is " + wrappedProviderUID.ToString() + "!";
throw new ArgumentException(errorMessage);
}
uint wrappedType = reader.ReadUInt32();
if (this.WrappedType != wrappedType)
{
if (this.ObjectType == StoreObjectType.Mailbox)
{
string errorMessage = "For Mailbox Store object, WrappedType MUST be %x0C.00.00.00, the actual value is " + StoreObjectType.Mailbox.ToString() + "!";
throw new ArgumentException(errorMessage);
}
else
{
string errorMessage = "For Public folder Store object, WrappedType MUST be %x06.00.00.00, the actual value is " + wrappedType.ToString() + "!";
throw new ArgumentException(errorMessage);
}
}
this.ServerShortname = reader.ReadASCIIString();
this.MailBoxDN = reader.ReadASCIIString();
return reader.Position;
}
private StoreObjectIdentifier(StoreObjectType storeObjectType, string name, string schema = null)
{
StoreObjectType = storeObjectType;
Name = name;
Schema = schema;
}
/// <summary>
/// Initializes a new instance of the StoreObjectEntryID class.
/// </summary>
public StoreObjectEntryID()
{
this.objectType = StoreObjectType.Mailbox;
}
/// <summary>
/// Deserialized byte array to an ActionBlock instance
/// </summary>
/// <param name="buffer">Byte array contain data of an ActionBlock instance.</param>
/// <returns>Bytes count that deserialized in buffer.</returns>
public uint Deserialize(byte[] buffer)
{
BufferReader reader = new BufferReader(buffer);
uint flags = reader.ReadUInt32();
if (this.Flags != flags)
{
string errorMessage = "Flags MUST be 0x00000000, the actual value is " + flags.ToString() + "!";
throw new ArgumentException(errorMessage);
}
byte[] providerUID = reader.ReadBytes(16);
if (!Common.CompareByteArray(this.ProviderUID, providerUID))
{
string errorMessage = "ProviderUID MUST be %x38.A1.BB.10.05.E5.10.1A.A1.BB.08.00.2B.2A.56.C2., the actual value is " + providerUID.ToString() + "!";
throw new ArgumentException(errorMessage);
}
byte version = reader.ReadByte();
if (this.Version != version)
{
string errorMessage = "Version MUST be zero., the actual value is " + version.ToString() + "!";
throw new ArgumentException(errorMessage);
}
byte flag = reader.ReadByte();
if (this.Flag != flag)
{
string errorMessage = "Flag MUST be zero, the actual value is " + flag.ToString() + "!";
throw new ArgumentException(errorMessage);
}
byte[] dllFileName = reader.ReadBytes(14);
if (!Common.CompareByteArray(this.DLLFileName, dllFileName))
{
string errorMessage = "DLLFileName MUST be set to the following value which represents \"emsmdb.dll\": %x45.4D.53.4D.44.42.2E.44.4C.4C.00.00.00.00., the actual value is " + dllFileName.ToString() + "!";
throw new ArgumentException(errorMessage);
}
uint wrappedFlags = reader.ReadUInt32();
if (this.WrappedFlags != wrappedFlags)
{
string errorMessage = "WrappedFlags MUST be 0x00000000, the actual value is " + wrappedFlags.ToString() + "!";
throw new ArgumentException(errorMessage);
}
byte[] wrappedProviderUID = reader.ReadBytes(16);
if (Common.CompareByteArray(this.mailboxWrappedProviderUID, wrappedProviderUID))
{
this.objectType = StoreObjectType.Mailbox;
}
else if (Common.CompareByteArray(this.publicFolderWrappedProviderUID, wrappedProviderUID))
{
this.objectType = StoreObjectType.PublicFolder;
}
else
{
string errorMessage = "WrappedProviderUID is not mailbox or public folder, the actual wrappedProviderUID value is " + wrappedProviderUID.ToString() + "!";
throw new ArgumentException(errorMessage);
}
uint wrappedType = reader.ReadUInt32();
if (this.WrappedType != wrappedType)
{
if (this.ObjectType == StoreObjectType.Mailbox)
{
string errorMessage = "For Mailbox Store object, WrappedType MUST be %x0C.00.00.00, the actual value is " + StoreObjectType.Mailbox.ToString() + "!";
throw new ArgumentException(errorMessage);
}
else
{
string errorMessage = "For Public folder Store object, WrappedType MUST be %x06.00.00.00, the actual value is " + wrappedType.ToString() + "!";
throw new ArgumentException(errorMessage);
}
}
this.ServerShortname = reader.ReadASCIIString();
this.MailBoxDN = reader.ReadASCIIString();
return(reader.Position);
}
private static StoreObjectType?TryDetectFolderTreeDataStoreObjectType(ICorePropertyBag propertyBag, string itemClass, StoreObjectType detectedType)
{
StoreObjectType?result = null;
if (ObjectClass.IsFolderTreeData(itemClass))
{
propertyBag.Load(new StorePropertyDefinition[]
{
FolderTreeDataSchema.GroupSection,
FolderTreeDataSchema.Type
});
FolderTreeDataSection?valueAsNullable = propertyBag.GetValueAsNullable <FolderTreeDataSection>(FolderTreeDataSchema.GroupSection);
FolderTreeDataType? valueAsNullable2 = propertyBag.GetValueAsNullable <FolderTreeDataType>(FolderTreeDataSchema.Type);
if (valueAsNullable == FolderTreeDataSection.Calendar)
{
if (valueAsNullable2 == FolderTreeDataType.Header)
{
result = new StoreObjectType?(StoreObjectType.CalendarGroup);
}
else if (valueAsNullable2 == FolderTreeDataType.NormalFolder || valueAsNullable2 == FolderTreeDataType.SharedFolder)
{
result = new StoreObjectType?(StoreObjectType.CalendarGroupEntry);
}
}
else if (valueAsNullable == FolderTreeDataSection.First)
{
result = new StoreObjectType?(StoreObjectType.FavoriteFolderEntry);
}
else if (valueAsNullable == FolderTreeDataSection.Tasks)
{
if (valueAsNullable2 == FolderTreeDataType.Header)
{
result = new StoreObjectType?(StoreObjectType.TaskGroup);
}
else if (valueAsNullable2 == FolderTreeDataType.NormalFolder)
{
result = new StoreObjectType?(StoreObjectType.TaskGroupEntry);
}
}
}
return(result);
}
internal static FolderCreateInfo GetFolderCreateInfo(StoreObjectType folderType)
{
return(FolderCreateInfo.folderCreateInfoDictionary[folderType]);
}
public new static ContactsFolder Create(StoreSession session, StoreId parentFolderId, StoreObjectType folderType, string displayName, CreateMode createMode)
{
EnumValidator.ThrowIfInvalid <CreateMode>(createMode, "createMode");
EnumValidator.ThrowIfInvalid <StoreObjectType>(folderType, StoreObjectType.ContactsFolder);
return((ContactsFolder)Folder.Create(session, parentFolderId, StoreObjectType.ContactsFolder, displayName, createMode));
}
public new static ContactsFolder Create(StoreSession session, StoreId parentFolderId, StoreObjectType folderType)
{
EnumValidator.ThrowIfInvalid <StoreObjectType>(folderType, StoreObjectType.ContactsFolder);
return(ContactsFolder.Create(session, parentFolderId));
}
private static Schema GetSchema(StoreObjectType objectType)
{
switch (objectType)
{
case StoreObjectType.Folder:
case StoreObjectType.CalendarFolder:
case StoreObjectType.ContactsFolder:
case StoreObjectType.TasksFolder:
case StoreObjectType.NotesFolder:
case StoreObjectType.JournalFolder:
case StoreObjectType.SearchFolder:
case StoreObjectType.OutlookSearchFolder:
case StoreObjectType.ShortcutFolder:
return(FolderSchema.Instance);
case StoreObjectType.Message:
case StoreObjectType.ConflictMessage:
case StoreObjectType.TaskRequest:
case StoreObjectType.Note:
case StoreObjectType.OofMessage:
case StoreObjectType.ExternalOofMessage:
return(MessageItemSchema.Instance);
case StoreObjectType.MeetingMessage:
case StoreObjectType.MeetingCancellation:
return(MeetingMessageInstanceSchema.Instance);
case StoreObjectType.MeetingRequest:
return(MeetingRequestSchema.Instance);
case StoreObjectType.MeetingResponse:
return(MeetingResponseSchema.Instance);
case StoreObjectType.CalendarItem:
return(CalendarItemSchema.Instance);
case StoreObjectType.CalendarItemOccurrence:
return(CalendarItemOccurrenceSchema.Instance);
case StoreObjectType.Contact:
return(ContactSchema.Instance);
case StoreObjectType.DistributionList:
return(DistributionListSchema.Instance);
case StoreObjectType.Task:
return(TaskSchema.Instance);
case StoreObjectType.Post:
return(PostItemSchema.Instance);
case StoreObjectType.Report:
return(ReportMessageSchema.Instance);
case StoreObjectType.MeetingForwardNotification:
return(MeetingForwardNotificationSchema.Instance);
case StoreObjectType.ConversationActionItem:
return(ConversationActionItemSchema.Instance);
case StoreObjectType.SharingMessage:
return(SharingMessageItemSchema.Instance);
case StoreObjectType.MeetingInquiryMessage:
return(MeetingInquiryMessageSchema.Instance);
case StoreObjectType.MailboxAssociationGroup:
return(MailboxAssociationGroupSchema.Instance);
case StoreObjectType.MailboxAssociationUser:
return(MailboxAssociationUserSchema.Instance);
case StoreObjectType.GroupMailboxRequestMessage:
return(GroupMailboxJoinRequestMessageSchema.Instance);
case StoreObjectType.ReminderMessage:
return(ReminderMessageSchema.Instance);
case StoreObjectType.Configuration:
return(ConfigurationItemSchema.Instance);
case StoreObjectType.HierarchySyncMetadata:
return(HierarchySyncMetadataItemSchema.Instance);
}
return(ItemSchema.Instance);
}
private SharingDataType(string containerClass, string externalName, bool isExternallySharable, string publishName, string publishResourceName, LocalizedString displayName, DefaultFolderType defaultFolderType, StoreObjectType storeObjectType)
{
Util.ThrowOnNullOrEmptyArgument(containerClass, "containerClass");
Util.ThrowOnNullOrEmptyArgument(externalName, "externalName");
this.PublishResourceName = publishResourceName;
this.ContainerClass = containerClass;
this.ExternalName = externalName;
this.IsExternallySharable = isExternallySharable;
this.PublishName = publishName;
this.DisplayName = displayName;
this.DefaultFolderType = defaultFolderType;
this.StoreObjectType = storeObjectType;
}
private static StoreObjectType?TryDetectRightsManagementStoreObjectType(ICorePropertyBag propertyBag, string itemClass, StoreObjectType detectedType)
{
if (detectedType != StoreObjectType.Message || !ObjectClass.IsRightsManagedContentClass(propertyBag.GetValueOrDefault <string>(CoreObjectSchema.ContentClass, null)))
{
return(null);
}
return(new StoreObjectType?(StoreObjectType.RightsManagedMessage));
}
private static StoreObjectType?TryDetectShortcutMessageEntryStoreObjectType(ICorePropertyBag propertyBag, string itemClass, StoreObjectType detectedType)
{
if (detectedType != StoreObjectType.Message || !ObjectClass.IsShortcutMessageEntry(propertyBag.GetValueOrDefault <int>(CoreItemSchema.FavLevelMask, -1)))
{
return(null);
}
return(new StoreObjectType?(StoreObjectType.ShortcutMessage));
}
private static void ParseChangeKeyString(string changeKey, out byte[] realChangeKey, out StoreObjectType objectType)
{
try
{
byte[] array = Convert.FromBase64String(changeKey);
int num = array.Length;
int num2 = 0;
if (num < 4)
{
throw new WebServiceProxyInvalidResponseException(Strings.InvalidChangeKeyReturned);
}
objectType = (StoreObjectType)BitConverter.ToInt32(array, num2);
num2 += 4;
if (!EnumValidator.IsValidValue <StoreObjectType>(objectType))
{
throw new WebServiceProxyInvalidResponseException(Strings.InvalidChangeKeyReturned);
}
if (num2 == num)
{
realChangeKey = null;
}
else
{
int num3 = BitConverter.ToInt32(array, num2);
num2 += 4;
if (num3 <= 0)
{
realChangeKey = null;
}
else
{
if (num3 > 512)
{
throw new WebServiceProxyInvalidResponseException(Strings.InvalidChangeKeyReturned);
}
if (num3 != num - num2)
{
throw new WebServiceProxyInvalidResponseException(Strings.InvalidChangeKeyReturned);
}
realChangeKey = new byte[num3];
Array.Copy(array, num2, realChangeKey, 0, num3);
num2 += num3;
}
}
}
catch (FormatException innerException)
{
throw new WebServiceProxyInvalidResponseException(Strings.InvalidChangeKeyReturned, innerException);
}
catch (ArgumentOutOfRangeException innerException2)
{
throw new WebServiceProxyInvalidResponseException(Strings.InvalidChangeKeyReturned, innerException2);
}
}
public static VersionedId Deserialize(byte[] providerSpecificId, byte[] byteArrayChangeKey, StoreObjectType objectType)
{
if (providerSpecificId == null || byteArrayChangeKey == null)
{
throw new ArgumentNullException();
}
StoreObjectId itemId = StoreObjectId.FromProviderSpecificId(providerSpecificId, objectType);
return(new VersionedId(itemId, byteArrayChangeKey));
}
public void New()
{
ExTraceGlobals.MailCallTracer.TraceDebug((long)this.GetHashCode(), "TreeEventHandler.New");
OwaStoreObjectId owaStoreObjectId = (OwaStoreObjectId)base.GetParameter("destId");
if (owaStoreObjectId.IsOtherMailbox)
{
throw new OwaInvalidRequestException("Cannot add new folder underneath a shared folder");
}
string text = (string)base.GetParameter("fC");
string text2 = (string)base.GetParameter("fN");
bool isExpanded = (bool)base.GetParameter("exp");
if (Utilities.IsDefaultFolderId(base.UserContext, owaStoreObjectId, DefaultFolderType.SearchFolders))
{
throw new OwaInvalidRequestException("Cannot Create new Search Folder through OWA");
}
if (Utilities.IsELCRootFolder(owaStoreObjectId, base.UserContext))
{
throw new OwaInvalidRequestException("Cannot create new folders under the root ELC folder.");
}
text2 = text2.Trim();
if (text2.Length == 0)
{
throw new OwaEventHandlerException("User did not provide name for new folder", LocalizedStrings.GetNonEncoded(-41080803), true);
}
StoreObjectType objectType = owaStoreObjectId.StoreObjectId.ObjectType;
if (!this.CanFolderHaveSubFolders(owaStoreObjectId))
{
throw new OwaInvalidRequestException("Cannot Create new Search Folder through OWA");
}
using (Folder folder = Utilities.CreateSubFolder(owaStoreObjectId, objectType, text2, base.UserContext))
{
folder.ClassName = text;
try
{
folder.Save();
}
catch (ObjectExistedException)
{
throw;
}
catch (StoragePermanentException innerException)
{
throw new OwaAccessDeniedException(LocalizedStrings.GetNonEncoded(995407892), innerException);
}
folder.Load();
OwaStoreObjectId newFolderId = OwaStoreObjectId.CreateFromStoreObject(folder);
this.RenderFolderTreeChangedNode(owaStoreObjectId, newFolderId, isExpanded, owaStoreObjectId.IsArchive, (FolderTreeRenderType)base.GetParameter("rdt"));
NavigationTreeDirtyFlag navigationTreeDirtyFlag = FolderTreeNode.GetAffectedTreeFromContainerClass(text);
if (owaStoreObjectId.IsArchive)
{
navigationTreeDirtyFlag |= NavigationTreeDirtyFlag.Favorites;
}
if (navigationTreeDirtyFlag != NavigationTreeDirtyFlag.Favorites || owaStoreObjectId.IsArchive)
{
RenderingUtilities.RenderNavigationTreeDirtyFlag(this.Writer, base.UserContext, navigationTreeDirtyFlag, (NavigationModule[])base.GetParameter("cms"));
}
}
}
/// <summary>
/// Parse the FolderEntryID structure.
/// </summary>
/// <param name="s">A stream containing the FolderEntryID structure</param>
public override void Parse(Stream s)
{
base.Parse(s);
this.Flags = ReadUint();
byte[] tempProviderUID = ReadBytes(16);
byte[] VerifyProviderUID = { 0x1A, 0x44, 0x73, 0x90, 0xAA, 0x66, 0x11, 0xCD, 0x9B, 0xC8, 0x00, 0xAA, 0x00, 0x2F, 0xC4, 0x5A };
if (tempProviderUID == VerifyProviderUID)
{
this.ProviderUID = tempProviderUID;
}
else
{
this.ProviderUID = new Guid(tempProviderUID);
}
this.FolderType = (StoreObjectType)ReadUshort();
this.DatabaseGuid = ReadGuid();
this.GlobalCounter = ReadBytes(6);
this.Pad = ReadUshort();
}
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 SyncStateUpgradeResult CheckAndUpgradeSyncStates(MailboxSession mailboxSession, DeviceIdentity deviceIdentity)
{
if (mailboxSession == null)
{
throw new ArgumentNullException("mailboxSession");
}
SafeHGlobalHandle safeHGlobalHandle = SafeHGlobalHandle.InvalidHandle;
TiFolderSyncUpgrade tiFolderSyncUpgrade = new TiFolderSyncUpgrade();
tiFolderSyncUpgrade.MailboxSession = mailboxSession;
MailboxUtility mailboxUtility = new MailboxUtility();
MailboxUtilityDeviceInfo mailboxUtilityDeviceInfo = null;
MemoryStream memoryStream = null;
try
{
mailboxUtility.MailboxSessionForUtility = mailboxSession;
mailboxUtilityDeviceInfo = mailboxUtility.GetDevice(deviceIdentity);
if (mailboxUtilityDeviceInfo == null)
{
AirSyncDiagnostics.TraceDebug <DeviceIdentity>(ExTraceGlobals.TiUpgradeTracer, null, "Failed to retrieve device info for: {0}", deviceIdentity);
return(SyncStateUpgradeResult.NoTiSyncState);
}
AirSyncDiagnostics.TraceDebug <DeviceIdentity>(ExTraceGlobals.TiUpgradeTracer, null, "Starting sync state upgrade for device: {0}", deviceIdentity);
safeHGlobalHandle = NativeMethods.AllocHGlobal(Marshal.SizeOf(typeof(FolderInfo)));
StoreObjectId storeObjectId = null;
storeObjectId = mailboxUtilityDeviceInfo.StoreObjectId;
HashSet <string> folderList = mailboxUtilityDeviceInfo.FolderList;
FolderInfo folderInfo = default(FolderInfo);
bool containsFoldersyncFile = false;
memoryStream = mailboxUtility.GetSyncState(storeObjectId, "FolderSyncFile");
if (memoryStream != null)
{
using (SafeHGlobalHandle safeHGlobalHandle2 = NativeMethods.AllocHGlobal((int)memoryStream.Length))
{
Marshal.Copy(memoryStream.GetBuffer(), 0, safeHGlobalHandle2.DangerousGetHandle(), (int)memoryStream.Length);
int num = SyncStateUpgrader.Foldersync_upgrade(safeHGlobalHandle2, (uint)memoryStream.Length, safeHGlobalHandle);
if (num != 0)
{
throw new AirSyncPermanentException(false);
}
}
folderInfo = (FolderInfo)Marshal.PtrToStructure(safeHGlobalHandle.DangerousGetHandle(), typeof(FolderInfo));
containsFoldersyncFile = true;
MailboxUtility.ReclaimStream(memoryStream);
memoryStream = null;
}
Dictionary <string, StoreObjectType> dictionary2;
Dictionary <string, StoreObjectId> dictionary = SyncStateUpgrader.UpgradeFolderSyncHierarchySyncState(tiFolderSyncUpgrade, containsFoldersyncFile, folderInfo, deviceIdentity, out dictionary2);
if (dictionary == null)
{
mailboxUtility.DeleteFolder(mailboxUtilityDeviceInfo.StoreObjectId, true);
}
else
{
SyncStateUpgradeHelper syncStateUpgradeHelper = new SyncStateUpgradeHelper(mailboxSession, tiFolderSyncUpgrade.SyncStateStorage);
foreach (string key in dictionary2.Keys)
{
StoreObjectType storeObjectType = dictionary2[key];
if (storeObjectType != StoreObjectType.Folder && storeObjectType != StoreObjectType.ContactsFolder && storeObjectType != StoreObjectType.CalendarFolder && storeObjectType != StoreObjectType.TasksFolder)
{
AirSyncDiagnostics.TraceDebug <StoreObjectType>(ExTraceGlobals.TiUpgradeTracer, null, "Removing unknown Ti folder of type {0}", storeObjectType);
dictionary.Remove(key);
}
}
if (!syncStateUpgradeHelper.UpgradeSyncState(dictionary, dictionary2, folderList, mailboxUtility, storeObjectId))
{
AirSyncDiagnostics.TraceDebug <string>(ExTraceGlobals.TiUpgradeTracer, null, "Failed to upgrade folders for {0}", mailboxUtilityDeviceInfo.DisplayName);
mailboxUtility.DeleteFolder(mailboxUtilityDeviceInfo.StoreObjectId, true);
return(SyncStateUpgradeResult.UpgradeFailed);
}
tiFolderSyncUpgrade.UpdateLastFolderId(syncStateUpgradeHelper.MaxFolderSeen);
}
AirSyncDiagnostics.FaultInjectionTracer.TraceTest(3236310333U);
}
catch (Exception arg)
{
if (mailboxUtilityDeviceInfo != null)
{
mailboxUtility.DeleteSyncStateStorage(new DeviceIdentity(mailboxUtilityDeviceInfo.DisplayName, mailboxUtilityDeviceInfo.ParentDisplayName, "AirSync"));
}
AirSyncDiagnostics.TraceDebug <DeviceIdentity, Exception>(ExTraceGlobals.TiUpgradeTracer, null, "Sync state upgrade failed for device: {0}\r\nException:\r\n{1}", deviceIdentity, arg);
throw;
}
finally
{
if (memoryStream != null)
{
MailboxUtility.ReclaimStream(memoryStream);
memoryStream = null;
}
if (mailboxUtilityDeviceInfo != null)
{
mailboxUtility.DeleteFolder(mailboxUtilityDeviceInfo.StoreObjectId, true);
}
if (tiFolderSyncUpgrade != null)
{
tiFolderSyncUpgrade.Close();
tiFolderSyncUpgrade = null;
}
safeHGlobalHandle.Close();
}
AirSyncDiagnostics.TraceDebug <DeviceIdentity>(ExTraceGlobals.TiUpgradeTracer, null, "Finished sync state upgrade for device: {0}", deviceIdentity);
return(SyncStateUpgradeResult.UpgradeComplete);
}
public static StoreObjectIdentifier?Create([NotNull] IReadOnlyEntityType entityType, StoreObjectType type)
{
Check.NotNull(entityType, nameof(entityType));
switch (type)
{
case StoreObjectType.Table:
var tableName = entityType.GetTableName();
return(tableName == null ? (StoreObjectIdentifier?)null : Table(tableName, entityType.GetSchema()));
case StoreObjectType.View:
var viewName = entityType.GetViewName();
return(viewName == null ? (StoreObjectIdentifier?)null : View(viewName, entityType.GetViewSchema()));
case StoreObjectType.SqlQuery:
var query = entityType.GetSqlQuery();
return(query == null ? (StoreObjectIdentifier?)null : SqlQuery(entityType));
case StoreObjectType.Function:
var functionName = entityType.GetFunctionName();
return(functionName == null ? (StoreObjectIdentifier?)null : DbFunction(functionName));
default:
return(null);
}
}
/// <summary>
/// Initializes a new instance of the StoreObjectEntryID class.
/// </summary>
/// <param name="objType">Type of Store object.</param>
public StoreObjectEntryID(StoreObjectType objType)
{
this.objectType = objType;
}
private bool CopyAndUpgradeCommon(CommonInfo commonInfo, StoreObjectId storeId, string parentServerId, StoreObjectType type, SafeHGlobalHandle pciInfo)
{
Dictionary <string, string> dictionary = null;
List <TagNode> list = null;
Dictionary <string, CommonNode> dictionary2 = new Dictionary <string, CommonNode>((int)commonInfo.NumCommonNodes);
string text = null;
long num = 1L;
TiSyncUpgrade tiSyncUpgrade = new TiSyncUpgrade(parentServerId, this.mailboxSession, this.syncStateStorage);
try
{
dictionary = new Dictionary <string, string>((int)commonInfo.NumMapping);
if (commonInfo.NumMapping > 0U)
{
MappingNodeStruct mappingNodeStruct = (MappingNodeStruct)Marshal.PtrToStructure(commonInfo.Mappingnodes, typeof(MappingNodeStruct));
int num2 = mappingNodeStruct.ShortId.LastIndexOf(':');
if (num2 != -1)
{
text = mappingNodeStruct.ShortId.Substring(0, num2);
uint num3;
if (uint.TryParse(text, out num3))
{
this.maxFolderSeen = ((this.maxFolderSeen > (int)num3) ? this.maxFolderSeen : ((int)num3));
}
else
{
this.needsParentId.Add(tiSyncUpgrade);
}
}
else
{
this.needsParentId.Add(tiSyncUpgrade);
}
for (uint num4 = 0U; num4 < commonInfo.NumMapping; num4 += 1U)
{
int num5 = mappingNodeStruct.LongId.LastIndexOf(':');
string key;
if (num5 != -1)
{
key = mappingNodeStruct.LongId.Substring(num5 + 1);
}
else
{
key = mappingNodeStruct.LongId;
}
dictionary.Add(key, mappingNodeStruct.ShortId);
num2 = mappingNodeStruct.ShortId.LastIndexOf(':');
if (num2 != -1)
{
string s = mappingNodeStruct.ShortId.Substring(num2 + 1);
uint num6;
if (uint.TryParse(s, out num6))
{
num = ((num > (long)((ulong)num6)) ? num : ((long)((ulong)num6)));
}
}
if (num4 < commonInfo.NumMapping - 1U)
{
mappingNodeStruct = (MappingNodeStruct)Marshal.PtrToStructure(mappingNodeStruct.Next, typeof(MappingNodeStruct));
}
}
}
else
{
this.needsParentId.Add(tiSyncUpgrade);
}
CommonNodeStruct commonNodeStruct;
if (commonInfo.NumCommonNodes > 0U)
{
commonNodeStruct = (CommonNodeStruct)Marshal.PtrToStructure(commonInfo.Nodes, typeof(CommonNodeStruct));
}
else
{
commonNodeStruct = default(CommonNodeStruct);
}
for (uint num7 = 0U; num7 < commonInfo.NumCommonNodes; num7 += 1U)
{
if (commonNodeStruct.SentToClient == 1)
{
if (!dictionary.ContainsKey(commonNodeStruct.ServerId))
{
dictionary.Add(commonNodeStruct.ServerId, commonNodeStruct.ServerId);
}
ExDateTime endTimeIn = (commonNodeStruct.EndTime == 0L) ? ExDateTime.MinValue : ExDateTime.FromFileTimeUtc(commonNodeStruct.EndTime);
dictionary2.Add(commonNodeStruct.ServerId, new CommonNode(commonNodeStruct.ServerId, commonNodeStruct.VersionId, commonNodeStruct.SentToClient, commonNodeStruct.IsEmail, commonNodeStruct.Read, commonNodeStruct.IsCalendar, endTimeIn));
}
if (num7 < commonInfo.NumCommonNodes - 1U)
{
commonNodeStruct = (CommonNodeStruct)Marshal.PtrToStructure(commonNodeStruct.Next, typeof(CommonNodeStruct));
}
}
list = new List <TagNode>((int)commonInfo.NumSupportedTags);
TagNodeStruct tagNodeStruct = default(TagNodeStruct);
if (commonInfo.NumSupportedTags > 0U)
{
tagNodeStruct = (TagNodeStruct)Marshal.PtrToStructure(commonInfo.Tagnodes, typeof(TagNodeStruct));
}
for (uint num8 = 0U; num8 < commonInfo.NumSupportedTags; num8 += 1U)
{
list.Add(new TagNode(tagNodeStruct.NameSpace, tagNodeStruct.Tag));
if (num8 < commonInfo.NumSupportedTags - 1U)
{
tagNodeStruct = (TagNodeStruct)Marshal.PtrToStructure(tagNodeStruct.Next, typeof(TagNodeStruct));
}
}
}
finally
{
SyncStateUpgradeHelper.Commoninfo_cleanup(pciInfo);
}
uint version;
switch (commonInfo.Version)
{
case 65542U:
version = 20U;
break;
case 65543U:
version = 21U;
break;
case 65544U:
version = 25U;
break;
default:
version = 10U;
break;
}
return(tiSyncUpgrade.Upgrade(storeId, dictionary2, dictionary, list, type, new string(commonInfo.SyncKey), text, (int)num, version));
}
// Token: 0x06002FC9 RID: 12233 RVA: 0x0011611C File Offset: 0x0011431C
internal static bool SetBody(Item item, string body, Markup markup, StoreObjectType storeObjectType, UserContext userContext)
{
bool flag = false;
switch (markup)
{
case Markup.Html:
{
string targetCharsetName;
BodyCharsetFlags bodyCharsetOptions = BodyConversionUtilities.GetBodyCharsetOptions(userContext, out targetCharsetName);
BodyFormat targetFormat = (storeObjectType != StoreObjectType.CalendarItem && storeObjectType != StoreObjectType.MeetingMessage) ? BodyFormat.TextHtml : BodyFormat.ApplicationRtf;
BodyWriteConfiguration bodyWriteConfiguration = new BodyWriteConfiguration(BodyFormat.TextHtml);
bodyWriteConfiguration.SetTargetFormat(targetFormat, targetCharsetName, bodyCharsetOptions);
OwaSafeHtmlInboundCallbacks owaSafeHtmlInboundCallbacks = null;
owaSafeHtmlInboundCallbacks = new OwaSafeHtmlInboundCallbacks(item, userContext);
bodyWriteConfiguration.SetHtmlOptions(HtmlStreamingFlags.None, owaSafeHtmlInboundCallbacks);
try
{
Body body2 = item.Body;
if (userContext.IsIrmEnabled && Utilities.IsIrmDecrypted(item))
{
body2 = ((RightsManagedMessageItem)item).ProtectedBody;
}
using (TextWriter textWriter = body2.OpenTextWriter(bodyWriteConfiguration))
{
textWriter.Write(body);
}
}
catch (InvalidCharsetException innerException)
{
throw new OwaEventHandlerException(LocalizedStrings.GetNonEncoded(1825027020), LocalizedStrings.GetNonEncoded(1825027020), innerException);
}
catch (TextConvertersException innerException2)
{
throw new OwaEventHandlerException(LocalizedStrings.GetNonEncoded(1825027020), LocalizedStrings.GetNonEncoded(1825027020), innerException2);
}
Utilities.MakeModifiedCalendarItemOccurrence(item);
bool flag2 = false;
if (owaSafeHtmlInboundCallbacks != null)
{
flag2 = owaSafeHtmlInboundCallbacks.AttachmentNeedsSave();
}
if (flag2 && !Utilities.IsClearSigned(item))
{
flag = AttachmentUtility.ApplyAttachmentsUpdates(item, owaSafeHtmlInboundCallbacks);
item.Load();
}
break;
}
case Markup.PlainText:
ItemUtility.SetItemBody(item, BodyFormat.TextPlain, body);
flag = AttachmentUtility.PromoteInlineAttachments(item);
if (flag)
{
item.Load();
}
break;
}
return(flag);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public static IEnumerable <IForeignKey> FindRowInternalForeignKeys(
[NotNull] this IEntityType entityType, [CanBeNull] string name, [CanBeNull] string schema, StoreObjectType objectType)
{
var primaryKey = entityType.FindPrimaryKey();
if (primaryKey == null ||
name == null)
{
yield break;
}
foreach (var fk in entityType.GetForeignKeys())
{
var principalEntityType = fk.PrincipalEntityType;
if (!fk.PrincipalKey.IsPrimaryKey() ||
principalEntityType == fk.DeclaringEntityType ||
!fk.IsUnique
#pragma warning disable EF1001 // Internal EF Core API usage.
|| !PropertyListComparer.Instance.Equals(fk.Properties, primaryKey.Properties))
#pragma warning restore EF1001 // Internal EF Core API usage.
{
continue;
}
switch (objectType)
{
case StoreObjectType.Table:
if (name == principalEntityType.GetTableName() &&
schema == principalEntityType.GetSchema())
{
yield return(fk);
}
break;
case StoreObjectType.View:
if (name == principalEntityType.GetViewName() &&
schema == principalEntityType.GetViewSchema())
{
yield return(fk);
}
break;
default:
throw new NotImplementedException(objectType.ToString());
}
}
}
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;
}
}
}
/// <summary>
/// Get store object EntryID bytes array.
/// </summary>
/// <param name="storeObjectType">Identify the store object is a mailbox or a public folder.</param>
/// <param name="serverShortName">Server short name string.</param>
/// <param name="mailboxDN">Mailbox DN string.</param>
/// <returns>Store object EntryID bytes array.</returns>
public byte[] GetStoreObjectEntryID(StoreObjectType storeObjectType, string serverShortName, string mailboxDN)
{
StoreObjectEntryID objectEntryId = new StoreObjectEntryID(storeObjectType)
{
ServerShortname = serverShortName,
MailBoxDN = mailboxDN
};
return objectEntryId.Serialize();
}
/// <summary>
/// Initializes a new instance of the StoreObjectEntryID class.
/// </summary>
/// <param name="objType">Type of Store object.</param>
public StoreObjectEntryID(StoreObjectType objType)
{
this.objectType = objType;
}
private PolicyAllowedMemberRights(StoreObjectType storeObjectType, SharingPolicyAction action, MemberRights allowedRights)
{
this.storeObjectType = storeObjectType;
this.action = action;
this.allowedRights = allowedRights;
}
/// <inheritdoc /> public override string ToString() => StoreObjectType.ToString() + " " + DisplayName();
// Token: 0x0600184D RID: 6221 RVA: 0x0008E8B4 File Offset: 0x0008CAB4
private static bool ParseSupportedTags(int version, List <TagNode> tags, StoreObjectType type)
{
if (tags.Count == 0 || version < 21)
{
return(true);
}
Dictionary <string, bool> dictionary = new Dictionary <string, bool>(tags.Count);
foreach (TagNode tagNode in tags)
{
if (tagNode.NameSpace == 2)
{
tagNode.NameSpace = 1;
}
else
{
if (tagNode.NameSpace != 3)
{
return(false);
}
tagNode.NameSpace = 4;
}
int tag = (int)tagNode.NameSpace << 8 | (int)(tagNode.Tag + 4);
string name = TiSyncUpgrade.wbxmlSchema.GetName(tag);
dictionary.Add(name, false);
}
IAirSyncVersionFactory airSyncVersionFactory = AirSyncProtocolVersionParserBuilder.FromVersion(version);
AirSyncSchemaState airSyncSchemaState;
switch (type)
{
case StoreObjectType.Folder:
airSyncSchemaState = airSyncVersionFactory.CreateEmailSchema(null);
break;
case StoreObjectType.CalendarFolder:
airSyncSchemaState = airSyncVersionFactory.CreateCalendarSchema();
break;
case StoreObjectType.ContactsFolder:
airSyncSchemaState = airSyncVersionFactory.CreateContactsSchema();
break;
case StoreObjectType.TasksFolder:
airSyncSchemaState = airSyncVersionFactory.CreateTasksSchema();
break;
default:
return(false);
}
AirSyncSetToDefaultStrategy airSyncSetToDefaultStrategy = new AirSyncSetToDefaultStrategy(dictionary);
AirSyncDataObject airSyncDataObject = airSyncSchemaState.GetAirSyncDataObject(new Hashtable(), airSyncSetToDefaultStrategy);
try
{
airSyncSetToDefaultStrategy.Validate(airSyncDataObject);
}
catch (ConversionException)
{
return(false);
}
return(true);
}
private static IProperty FindSharedObjectRootPrimaryKeyProperty([NotNull] IProperty property, StoreObjectType storeObjectType)
{
Check.NotNull(property, nameof(property));
var principalProperty = property;
HashSet <IEntityType> visitedTypes = null;
while (true)
{
var linkingRelationship = principalProperty.FindSharedObjectLink(storeObjectType);
if (linkingRelationship == null)
{
break;
}
if (visitedTypes == null)
{
visitedTypes = new HashSet <IEntityType> {
linkingRelationship.DeclaringEntityType
};
}
if (!visitedTypes.Add(linkingRelationship.PrincipalEntityType))
{
return(null);
}
principalProperty = linkingRelationship.PrincipalKey.Properties[linkingRelationship.Properties.IndexOf(principalProperty)];
}
return(principalProperty == property ? null : principalProperty);
}
// Token: 0x0600184C RID: 6220 RVA: 0x0008E670 File Offset: 0x0008C870
public bool Upgrade(StoreObjectId storeId, Dictionary <string, CommonNode> items, Dictionary <string, string> mapping, List <TagNode> tags, StoreObjectType type, string synckeyIn, string shortParentId, int nextShortId, uint version)
{
if (storeId == null)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.TiUpgradeTracer, this, "Input to TiSyncUpgrade.Upgrade is null: field storeId");
throw new ArgumentNullException("storeId");
}
if (items == null)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.TiUpgradeTracer, this, "Input to TiSyncUpgrade.Upgrade is null: field items");
throw new ArgumentNullException("items");
}
if (mapping == null)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.TiUpgradeTracer, this, "Input to TiSyncUpgrade.Upgrade is null: field mapping");
throw new ArgumentNullException("mapping");
}
if (tags == null)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.TiUpgradeTracer, this, "Input to TiSyncUpgrade.Upgrade is null: field tags");
throw new ArgumentNullException("tags");
}
if (synckeyIn == null)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.TiUpgradeTracer, this, "Input to TiSyncUpgrade.Upgrade is null: field synckeyIn");
throw new ArgumentNullException("synckeyIn");
}
if (shortParentId == null && mapping.Count > 0)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.TiUpgradeTracer, this, "Input to TiSyncUpgrade.Upgrade is null: field shortParentId, and mapping.Count > 0");
throw new ArgumentNullException("shortParentId");
}
Dictionary <StoreObjectId, string> dictionary = new Dictionary <StoreObjectId, string>();
this.storeId = storeId;
try
{
this.LoadE12SyncState(storeId, shortParentId, nextShortId);
Folder sourceFolder = null;
try
{
sourceFolder = Folder.Bind(this.mailboxSession, storeId, null);
}
catch (ObjectNotFoundException)
{
return(false);
}
if (!TiSyncUpgrade.ParseSupportedTags((int)version, tags, type))
{
return(false);
}
Dictionary <string, CommonNode> items2 = new Dictionary <string, CommonNode>(items);
ItemSyncUpgrade itemSyncUpgrade = new ItemSyncUpgrade();
dictionary = itemSyncUpgrade.Upgrade(this.syncState, items, sourceFolder, this.mailboxSession);
if (dictionary == null)
{
return(false);
}
DateTimeCustomSyncFilter dateTimeFilter = new DateTimeCustomSyncFilter(this.syncState);
this.UpdateFilter(dictionary, dateTimeFilter, items2);
this.UpdateMapping(dictionary, mapping);
this.syncState[CustomStateDatumType.AirSyncProtocolVersion] = new Int32Data((int)version);
((ItemIdMapping)this.syncState[CustomStateDatumType.IdMapping]).CommitChanges();
string text = synckeyIn;
int num = text.LastIndexOf("}");
if (num >= 0)
{
text = text.Substring(num + 1, text.Length - num - 1);
}
uint data = (uint)int.Parse(text, CultureInfo.InvariantCulture);
this.syncState[CustomStateDatumType.SyncKey] = new UInt32Data(data);
this.syncState.Commit();
}
finally
{
if (this.syncState != null)
{
this.syncState.Dispose();
}
}
return(true);
}
// Token: 0x06002DB9 RID: 11705 RVA: 0x00102FA4 File Offset: 0x001011A4
private void NonEditResponseInternal(bool sendResponse)
{
ResponseType responseType = (ResponseType)base.GetParameter("Rsp");
StoreObjectType storeObjectType = (StoreObjectType)base.GetParameter("ItemType");
MeetingRequest meetingRequest = null;
CalendarItemBase calendarItemBase = null;
try
{
StoreObjectType storeObjectType2 = storeObjectType;
if (storeObjectType2 != StoreObjectType.MeetingRequest)
{
if (storeObjectType2 == StoreObjectType.CalendarItem)
{
calendarItemBase = base.GetRequestItem <CalendarItemBase>(new PropertyDefinition[0]);
MeetingUtilities.ThrowIfMeetingResponseInvalid(calendarItemBase);
}
}
else
{
this.properties = new PropertyDefinition[]
{
MeetingMessageSchema.CalendarProcessed,
StoreObjectSchema.ParentItemId
};
meetingRequest = this.GetMeetingRequest(this.properties);
calendarItemBase = MeetingUtilities.UpdateCalendarItem(meetingRequest);
if (calendarItemBase == null)
{
throw new OwaInvalidRequestException(string.Format("calendarItem associated with meetingRequest with Id {0} is null.", base.GetParameter("Id")));
}
}
this.UpdateItem(calendarItemBase);
Utilities.SaveItem(calendarItemBase);
calendarItemBase.Load();
MeetingUtilities.NonEditResponse(responseType, calendarItemBase, sendResponse, null);
calendarItemBase.Load();
if (meetingRequest != null)
{
this.UpdateItem(meetingRequest);
Utilities.SaveItem(meetingRequest);
MeetingUtilities.DeleteMeetingRequestAfterResponse(meetingRequest);
}
if (storeObjectType == StoreObjectType.CalendarItem)
{
this.Writer.Write("<div id=nid>");
this.Writer.Write(OwaStoreObjectId.CreateFromStoreObject(calendarItemBase).ToBase64String());
this.Writer.Write("</div>");
}
}
finally
{
if (meetingRequest != null)
{
meetingRequest.Dispose();
meetingRequest = null;
}
if (calendarItemBase != null)
{
calendarItemBase.Dispose();
calendarItemBase = null;
}
}
}
public bool Rename(StoreObjectId destinationId, string folderName)
{
if (destinationId == null)
{
throw new ArgumentNullException("destinationId");
}
if (folderName == null)
{
throw new ArgumentNullException("folderName");
}
folderName = folderName.Trim();
if (folderName.Length == 0)
{
this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(615663605, InfobarMessageType.Error);
return(false);
}
if (folderName.Length > 256)
{
this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(-1198351885, InfobarMessageType.Error);
return(false);
}
StoreObjectType objectType = destinationId.ObjectType;
FolderSaveResult folderSaveResult;
try
{
Folder folder2;
Folder folder = folder2 = Folder.Bind(this.owaContext.UserContext.MailboxSession, destinationId);
try
{
folder.DisplayName = folderName;
folderSaveResult = folder.Save();
}
finally
{
if (folder2 != null)
{
((IDisposable)folder2).Dispose();
}
}
}
catch (ObjectNotFoundException)
{
this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(2106120183, InfobarMessageType.Error);
return(false);
}
catch (ObjectValidationException)
{
this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(2103130667, InfobarMessageType.Error);
return(false);
}
catch (InvalidOperationException)
{
this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(2103130667, InfobarMessageType.Error);
return(false);
}
catch (StoragePermanentException e)
{
InfobarMessage.PutExceptionInfoIntoContextInfobarMessage(e, this.owaContext);
return(false);
}
catch (StorageTransientException e2)
{
InfobarMessage.PutExceptionInfoIntoContextInfobarMessage(e2, this.owaContext);
return(false);
}
if (folderSaveResult.OperationResult != OperationResult.Succeeded)
{
if (folderSaveResult.PropertyErrors.Length > 0)
{
switch (folderSaveResult.PropertyErrors[0].PropertyErrorCode)
{
case PropertyErrorCode.MapiCallFailed:
this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(2103130667, InfobarMessageType.Error);
return(false);
case PropertyErrorCode.FolderNameConflict:
this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(1602494619, InfobarMessageType.Error);
return(false);
}
}
this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(2103130667, InfobarMessageType.Error);
return(false);
}
this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateText(string.Format(LocalizedStrings.GetNonEncoded(-889243793), folderName), InfobarMessageType.Informational);
return(true);
}
/// <summary>
/// Verify the FolderEntryID structure.
/// </summary>
/// <param name="folderEntryID">The FolderEntryID to be verified.</param>
/// <param name="storeObjectType">Store Object Type.</param>
private void VerifyFolderEntryID(FolderEntryID folderEntryID, StoreObjectType storeObjectType)
{
// Add the debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXCDATA_R2225");
// Verify MS-OXCDATA requirement: MS-OXCDATA_R2225.
Site.CaptureRequirementIfAreEqual<int>(
0,
BitConverter.ToInt32(folderEntryID.Flag, 0),
"MS-OXCDATA",
2225,
@"[In Folder EntryID Structure] Flags (4 bytes): This value MUST be set to 0x00000000.");
// Add the debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXCDATA_R2229");
// Verify MS-OXCDATA requirement: MS-OXCDATA_R2229.
Site.CaptureRequirementIfAreEqual<int>(
16,
folderEntryID.DataBaseGUID.Length,
"MS-OXCDATA",
2229,
@"[In Folder EntryID Structure] DatabaseGuid (16 bytes): A GUID associated with the Store object and corresponding to the ReplicaId field of the FID structure.");
// Add the debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXCDATA_R2230");
// Verify MS-OXCDATA requirement: MS-OXCDATA_R2230.
Site.CaptureRequirementIfAreEqual<int>(
6,
folderEntryID.GlobalCounter.Length,
"MS-OXCDATA",
2230,
@"[In Folder EntryID Structure] GlobalCounter (6 bytes): An unsigned integer identifying the folder.");
// Add the debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXCDATA_R2231");
// Verify MS-OXCDATA requirement: MS-OXCDATA_R2231.
Site.CaptureRequirementIfAreEqual<short>(
0,
BitConverter.ToInt16(folderEntryID.Pad, 0),
"MS-OXCDATA",
2231,
@"[In Folder EntryID Structure] Pad (2 bytes): This value MUST be set to zero.");
// Add the debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXORULE_R301");
// The structure of FolderEId is verified by the requirements MS-OXCDATA_R2225, MS-OXCDATA_R2229, MS-OXCDATA_R2230, and MS-OXCDATA_R2231.
// Verify MS-OXORULE_R301.
Site.CaptureRequirement(
301,
@"[In OP_MOVE and OP_COPY ActionData Structure] [Buffer Format for Standard Rules] FolderEID (variable): A structure that identifies the destination folder.");
if (storeObjectType == StoreObjectType.Mailbox)
{
// Add the debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXCDATA_R2226");
// Verify MS-OXCDATA requirement: MS-OXCDATA_R2226.
Site.CaptureRequirementIfAreEqual<byte[]>(
this.mailboxGUID,
folderEntryID.ProviderUID,
"MS-OXCDATA",
2226,
@"[In Folder EntryID Structure] Provider UID (16 bytes): For a folder in a private mailbox, this value MUST be set to value of the MailboxGuid field from the RopLogon ROP response buffer ([MS-OXCROPS] section 2.2.3.1).");
}
}
internal RightsNotAllowedByPolicyException(RightsNotAllowedRecipient[] rightsNotAllowedRecipients, StoreObjectType storeObjectType, string folderName) : base(ServerStrings.RightsNotAllowedByPolicy(storeObjectType.ToString(), folderName))
{
if (rightsNotAllowedRecipients == null)
{
throw new ArgumentNullException("rightsNotAllowedRecipients");
}
if (rightsNotAllowedRecipients.Length == 0)
{
throw new ArgumentException("rightsNotAllowedRecipients");
}
this.rightsNotAllowedRecipients = rightsNotAllowedRecipients;
}
/// <summary>
/// Parse the MessageEntryID structure.
/// </summary>
/// <param name="s">A stream containing the MessageEntryID structure</param>
public override void Parse(Stream s)
{
base.Parse(s);
this.Flags = ReadUint();
byte[] tempProviderUID = ReadBytes(16);
if (tempProviderUID.ToString() == "%x1A.44.73.90.AA.66.11.CD.9B.C8.00.AA.00.2F.C4.5A")
{
this.ProviderUID = tempProviderUID;
}
else
{
this.ProviderUID = new Guid(tempProviderUID);
}
this.MessageType = (StoreObjectType)ReadUshort();
this.FolderDatabaseGuid = ReadGuid();
this.FolderGlobalCounter = ReadBytes(6);
this.Pad_1 = ReadUshort();
this.MessageDatabaseGuid = ReadGuid();
this.MessageGlobalCounter = ReadBytes(6);
this.Pad_2 = ReadUshort();
}
/// <summary>
/// Get folder EntryID bytes array.
/// </summary>
/// <param name="storeObjectType">Identify the store object is a mailbox or a public folder.</param>
/// <param name="objHandle">Logon handle.</param>
/// <param name="folderid">Folder id value.</param>
/// <returns>Folder EntryID bytes array.</returns>
public byte[] GetFolderEntryId(StoreObjectType storeObjectType, uint objHandle, ulong folderid)
{
// Get folder longterm id.
RopLongTermIdFromIdResponse longTermIdFromId = this.GetLongTermId(objHandle, folderid);
FolderEntryID folderEntryId;
if (storeObjectType == StoreObjectType.Mailbox)
{
folderEntryId = new FolderEntryID(storeObjectType, this.mailboxGUID, longTermIdFromId.LongTermId.DatabaseGuid, longTermIdFromId.LongTermId.GlobalCounter);
}
else
{
byte[] providerUID = new byte[] { 0x1A, 0x44, 0x73, 0x90, 0xAA, 0x66, 0x11, 0xCD, 0x9B, 0xC8, 0x00, 0xAA, 0x00, 0x2F, 0xC4, 0x5A };
folderEntryId = new FolderEntryID(storeObjectType, providerUID, longTermIdFromId.LongTermId.DatabaseGuid, longTermIdFromId.LongTermId.GlobalCounter);
}
this.VerifyFolderEntryID(folderEntryId, storeObjectType);
return folderEntryId.Serialize();
}
