internal static WellKnownFolderMapping FindWKFMapping(WellKnownFolderType wkfType, int flags)
{
if (wkfType == WellKnownFolderType.None)
{
return(null);
}
MailboxRootFolderMapping[] array = ((FolderHierarchyFlags)flags).HasFlag(FolderHierarchyFlags.PublicFolderMailbox) ? FolderHierarchyUtils.PublicFolderMailboxRefs : FolderHierarchyUtils.MailboxRefs;
foreach (MailboxRootFolderMapping mailboxRootFolderMapping in array)
{
if (mailboxRootFolderMapping.WKFType == wkfType)
{
return(mailboxRootFolderMapping);
}
}
foreach (InboxFolderMapping inboxFolderMapping in FolderHierarchyUtils.InboxRefs)
{
if (inboxFolderMapping.WKFType == wkfType)
{
return(inboxFolderMapping);
}
}
foreach (NamedFolderMapping namedFolderMapping in FolderHierarchyUtils.NamedFolderRefs)
{
if (namedFolderMapping.WKFType == wkfType)
{
return(namedFolderMapping);
}
}
return(null);
}
private ConflictResolutionOption GetConflictResolutionOption(FolderMapping fm)
{
WellKnownFolderType wkftype = fm.WKFType;
switch (wkftype)
{
case WellKnownFolderType.DumpsterDeletions:
case WellKnownFolderType.DumpsterVersions:
case WellKnownFolderType.DumpsterPurges:
break;
default:
switch (wkftype)
{
case WellKnownFolderType.DumpsterAdminAuditLogs:
case WellKnownFolderType.DumpsterAudits:
break;
default:
{
ConflictResolutionOption?conflictResolutionOption = base.MRSJob.CachedRequestJob.ConflictResolutionOption;
if (conflictResolutionOption == null)
{
return(ConflictResolutionOption.KeepSourceItem);
}
return(conflictResolutionOption.GetValueOrDefault());
}
}
break;
}
return(ConflictResolutionOption.KeepAll);
}
private void HashFolderMessages(WellKnownFolderType wkfType, HashSet <byte[]> hashset)
{
MrsTracer.Service.Debug("Enumerating target {0} folder to check for deleted messages", new object[]
{
wkfType
});
FolderMapping wellKnownFolder = this.DestHierarchy.GetWellKnownFolder(wkfType);
if (wellKnownFolder != null)
{
using (IDestinationFolder folder = base.DestMailbox.GetFolder(wellKnownFolder.EntryId))
{
if (folder != null)
{
List <MessageRec> list = folder.EnumerateMessages(EnumerateMessagesFlags.RegularMessages, this.GetEnumerateMessagesPropsForContentVerification(MailboxWrapperFlags.Target));
foreach (MessageRec messageRec in list)
{
byte[] array = messageRec[this.DestHierarchy.SourceEntryIDPtag] as byte[];
if (array != null && !hashset.Contains(array))
{
hashset.Add(array);
}
}
}
}
}
}
public void Add(WellKnownFolderType wkfType, FolderMapping fm)
{
fm.WKFType = wkfType;
this.wellKnownFolders[wkfType] = fm;
if (fm.EntryId != null)
{
this.wellKnownFolderTypes[fm.EntryId] = wkfType;
}
}
public FolderMapping GetWellKnownFolder(WellKnownFolderType wkfType)
{
FolderMapping result;
if (this.wellKnownFolders.TryGetValue(wkfType, out result))
{
return(result);
}
return(null);
}
List <WellKnownFolder> IMailbox.DiscoverWellKnownFolders(int flags)
{
List <WellKnownFolder> list = new List <WellKnownFolder>();
list.Add(new WellKnownFolder(3, ImapMailbox.IpmSubtreeEntryId));
foreach (ImapClientFolder imapClientFolder in this.folderCache.Values)
{
if (imapClientFolder.WellKnownFolderType != WellKnownFolderType.None)
{
WellKnownFolderType wellKnownFolderType = imapClientFolder.WellKnownFolderType;
byte[] entryId = ImapEntryId.CreateFolderEntryId(imapClientFolder.Name);
list.Add(new WellKnownFolder((int)wellKnownFolderType, entryId));
}
}
return(list);
}
public static void Parse(string folderPath, out WellKnownFolderType root, out List <string> folderNames, out FolderMappingFlags inheritanceFlags)
{
folderNames = new List <string>();
root = WellKnownFolderType.IpmSubtree;
inheritanceFlags = FolderMappingFlags.None;
if (folderPath.EndsWith("/"))
{
folderPath = folderPath.Substring(0, folderPath.Length - "/".Length);
}
else if (folderPath.EndsWith("/*"))
{
folderPath = folderPath.Substring(0, folderPath.Length - "/*".Length);
inheritanceFlags = FolderMappingFlags.Inherit;
}
bool flag = true;
int i = 0;
while (i < folderPath.Length)
{
string nextSubfolderName = FolderFilterParser.GetNextSubfolderName(folderPath, ref i);
if (flag)
{
WellKnownFolderType wellKnownFolderType = WellKnownFolderType.None;
if (folderPath[0] != '\\')
{
wellKnownFolderType = FolderFilterParser.CheckAlias(nextSubfolderName);
}
if (wellKnownFolderType != WellKnownFolderType.None)
{
root = wellKnownFolderType;
}
else
{
folderNames.Add(nextSubfolderName);
}
flag = false;
}
else
{
folderNames.Add(nextSubfolderName);
}
}
}
public override void CopyFolderProperties(FolderRecWrapper folderRec, ISourceFolder sourceFolder, IDestinationFolder destFolder, FolderRecDataFlags dataToCopy, out bool wasPropertyCopyingSkipped)
{
base.CopyFolderProperties(folderRec, sourceFolder, destFolder, dataToCopy, out wasPropertyCopyingSkipped);
MrsTracer.Service.Debug("Stamping additional properties on the target folder", new object[0]);
List <PropValueData> list = new List <PropValueData>(3);
list.Add(new PropValueData(this.DestHierarchy.SourceEntryIDPtag, folderRec.EntryId));
list.Add(new PropValueData(this.DestHierarchy.SourceLastModifiedTimestampPtag, folderRec.FolderRec.LastModifyTimestamp));
WellKnownFolderType wellKnownFolderType = WellKnownFolderType.None;
if (this.SourceHierarchy != null)
{
wellKnownFolderType = this.SourceHierarchy.GetWellKnownFolderType(folderRec.EntryId);
}
if (wellKnownFolderType != WellKnownFolderType.None)
{
list.Add(new PropValueData(this.DestHierarchy.SourceWKFTypePtag, (int)wellKnownFolderType));
}
destFolder.SetProps(list.ToArray());
}
private void SetWellKnownFolder(WellKnownFolderType wkfType, FolderMapping folder)
{
if (folder != null && (this.MbxWrapper.Flags & MailboxWrapperFlags.Archive) != (MailboxWrapperFlags)0)
{
foreach (WellKnownFolderType wellKnownFolderType in FolderHierarchy.ArchiveMovedFolders)
{
if (wellKnownFolderType == wkfType)
{
folder = null;
break;
}
}
}
if (wkfType != WellKnownFolderType.None)
{
this.wellKnownFolderMap.Remove(wkfType);
if (folder != null)
{
this.wellKnownFolderMap.Add(wkfType, folder);
}
}
}
public void Remove(WellKnownFolderType wkfType)
{
FolderMapping wellKnownFolder = this.GetWellKnownFolder(wkfType);
if (wellKnownFolder != null)
{
wellKnownFolder.WKFType = WellKnownFolderType.None;
this.wellKnownFolders.Remove(wkfType);
byte[] array = null;
foreach (KeyValuePair <byte[], WellKnownFolderType> keyValuePair in this.wellKnownFolderTypes)
{
if (keyValuePair.Value == wkfType)
{
array = keyValuePair.Key;
break;
}
}
if (array != null)
{
this.wellKnownFolderTypes.Remove(array);
}
}
}
private void WriteWellKnownFolderReferenceToFolder(WellKnownFolderType targetFolderType, WellKnownFolderType wkfType, PropTagFolderMapping ptfm, byte[] folderId)
{
FolderMapping wellKnownFolder = this.GetWellKnownFolder(targetFolderType);
if (wellKnownFolder == null && targetFolderType == WellKnownFolderType.NonIpmSubtree)
{
wellKnownFolder = this.GetWellKnownFolder(WellKnownFolderType.Root);
}
if (wellKnownFolder == null)
{
MrsTracer.Service.Warning("There's no {0} in the target mailbox, not writing WKF reference for {1}", new object[]
{
targetFolderType,
wkfType
});
}
IDestinationMailbox destinationMailbox = this.MbxWrapper.Mailbox as IDestinationMailbox;
using (IDestinationFolder folder = destinationMailbox.GetFolder(wellKnownFolder.EntryId))
{
if (folder == null)
{
MrsTracer.Service.Error("{0} disappeared??? Not writing WKF reference for {1}", new object[]
{
targetFolderType,
wkfType
});
}
else
{
this.WriteEntryIdReference(ptfm, folderId, (PropTag[] pta) => folder.GetProps(pta), delegate(PropValueData[] pvda)
{
folder.SetProps(pvda);
});
}
}
}
private void WriteWellKnownFolderReference(WellKnownFolderType wkfType, byte[] folderId)
{
WellKnownFolderMapping wellKnownFolderMapping = FolderHierarchyUtils.FindWKFMapping(wkfType, (int)this.Flags);
PropTagFolderMapping propTagFolderMapping = wellKnownFolderMapping as PropTagFolderMapping;
if (propTagFolderMapping != null)
{
if (propTagFolderMapping is MailboxRootFolderMapping)
{
IDestinationMailbox mbx = this.MbxWrapper.Mailbox as IDestinationMailbox;
this.WriteEntryIdReference(propTagFolderMapping, folderId, (PropTag[] pta) => mbx.GetProps(pta), delegate(PropValueData[] pvda)
{
mbx.SetProps(pvda);
});
return;
}
if (propTagFolderMapping is InboxFolderMapping)
{
this.WriteWellKnownFolderReferenceToFolder(WellKnownFolderType.Inbox, wkfType, propTagFolderMapping, folderId);
this.WriteWellKnownFolderReferenceToFolder(WellKnownFolderType.NonIpmSubtree, wkfType, propTagFolderMapping, folderId);
return;
}
}
else
{
if (wellKnownFolderMapping is NamedFolderMapping)
{
return;
}
MrsTracer.Service.Warning("Unable to write WKF reference {0} -> {1}", new object[]
{
wkfType,
TraceUtils.DumpEntryId(folderId)
});
}
}
public InboxIndexedFolderMapping(WellKnownFolderType wkft, ExtraPropTag ptag, int entryIndex) : base(wkft, ptag)
{
this.EntryIndex = entryIndex;
}
public FolderMapping GetWellKnownFolder(WellKnownFolderType wkfType)
{
return(this.wellKnownFolderMap.GetWellKnownFolder(wkfType));
}
public void SetFolderFilter(string[] includeFolders, bool includeDumpster, string[] excludeFolders, string sourceRootFolder, bool isLivePublicFolderMailboxRestore, Guid sourceMailboxGuid)
{
if (this.folderFilterApplied)
{
throw new ArgumentException("SetFolderFilter was already called");
}
this.folderFilterApplied = true;
if (includeFolders == null || includeFolders.Length == 0)
{
includeFolders = new string[]
{
"/*"
};
}
foreach (string folderPath in includeFolders)
{
this.MarkFolderByPath(sourceRootFolder, folderPath, true);
}
if (includeDumpster)
{
FolderMapping wellKnownFolder = this.GetWellKnownFolder(WellKnownFolderType.Dumpster);
if (wellKnownFolder != null)
{
wellKnownFolder.Flags = (FolderMappingFlags.Include | FolderMappingFlags.Inherit);
}
}
if (excludeFolders != null)
{
foreach (string folderPath2 in excludeFolders)
{
this.MarkFolderByPath(sourceRootFolder, folderPath2, false);
}
}
base.EnumerateFolderHierarchy(EnumHierarchyFlags.AllFolders, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx)
{
FolderMapping folderMapping = (FolderMapping)fRec;
WellKnownFolderType wkftype = folderMapping.WKFType;
switch (wkftype)
{
case WellKnownFolderType.FreeBusy:
case WellKnownFolderType.OfflineAddressBook:
break;
default:
if (wkftype != WellKnownFolderType.System)
{
switch (wkftype)
{
case WellKnownFolderType.DumpsterAdminAuditLogs:
case WellKnownFolderType.DumpsterAudits:
case WellKnownFolderType.SpoolerQueue:
case WellKnownFolderType.TransportQueue:
case WellKnownFolderType.MRSSyncStates:
break;
case WellKnownFolderType.ConversationActionSettings:
return;
default:
return;
}
}
break;
}
folderMapping.Flags &= ~FolderMappingFlags.Include;
folderMapping.Flags |= (FolderMappingFlags.Exclude | FolderMappingFlags.Inherit);
});
bool hasIncludedFolders = false;
base.EnumerateFolderHierarchy(EnumHierarchyFlags.AllFolders, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx)
{
FolderMapping folderMapping = (FolderMapping)fRec;
if (this.IsPublicFolderMailbox && folderMapping.IsPublicFolderDumpster && !includeDumpster)
{
return;
}
folderMapping.ApplyInheritanceFlags();
if (includeDumpster)
{
this.MarkPublicFolderDumpster(fRec);
}
if ((folderMapping.Flags & FolderMappingFlags.Include) != FolderMappingFlags.None)
{
hasIncludedFolders = true;
}
});
if (isLivePublicFolderMailboxRestore)
{
this.CheckFolderRestorePossible(sourceMailboxGuid);
}
if (!hasIncludedFolders)
{
this.Warnings.Add(MrsStrings.NoFoldersIncluded);
}
}
public MailboxRootFolderMapping(WellKnownFolderType wkft, ExtraPropTag ptag)
{
base.Ptag = (PropTag)ptag;
base.WKFType = wkft;
}
public NamedFolderMapping(WellKnownFolderType wkft, WellKnownFolderType parentType, string folderName)
{
base.WKFType = wkft;
this.ParentType = parentType;
this.FolderName = folderName;
}
public InboxFolderMapping(WellKnownFolderType wkft, PropTag ptag)
{
base.Ptag = ptag;
base.WKFType = wkft;
}
public static string GetAlias(WellKnownFolderType wkfType)
{
return('#' + wkfType.ToString() + '#');
}
public static bool IsDumpster(WellKnownFolderType folderType)
{
return(FolderFilterParser.dumpsterIds.Contains(folderType));
}
internal static BadMessageRec MisplacedFolder(FolderRec folderRec, string folderPath, WellKnownFolderType wkfType, byte[] destParentId)
{
return(new BadMessageRec
{
Kind = BadItemKind.MisplacedFolder,
EntryId = BadMessageRec.ComputeKey(folderRec.EntryId, BadItemKind.MisplacedFolder),
FolderId = folderRec.EntryId,
FolderName = folderPath,
WellKnownFolderType = wkfType
});
}
public InboxNamedPropFolderMapping(WellKnownFolderType wkft, NamedPropData namedPropData) : base(wkft, PropTag.Null)
{
this.NamedPropData = namedPropData;
}