protected virtual ILoadBalanceService CreateLoadBalancerClient(DirectoryServer server, IDirectoryProvider directory)
{
ILoadBalanceService result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
LoadBalancerClient loadBalancerClient = LoadBalancerClient.Create(server.Fqdn, directory, this.logger);
disposeGuard.Add <LoadBalancerClient>(loadBalancerClient);
bool flag = true;
ILoadBalanceService loadBalanceService = loadBalancerClient;
if (!loadBalancerClient.ServerVersion[1])
{
flag = false;
loadBalanceService = this.CreateCompatibilityLoadBalanceClient(server);
}
else if (!loadBalancerClient.ServerVersion[2])
{
loadBalanceService = new SoftDeletedRemovalCapabilityDecorator(loadBalanceService, server);
}
if (!loadBalancerClient.ServerVersion[3])
{
loadBalanceService = new ConsumerMetricsLoadBalanceCapabilityDecorator(loadBalanceService, server);
}
if (!loadBalancerClient.ServerVersion[5])
{
loadBalanceService = new CapacitySummaryCapabilityDecorator(loadBalanceService, server, this.serviceContext);
}
if (flag)
{
disposeGuard.Success();
}
result = loadBalanceService;
}
return(result);
}
protected virtual IInjectorService CreateInjectorClient(DirectoryServer server, IDirectoryProvider directory)
{
IInjectorService result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
InjectorClient injectorClient = InjectorClient.Create(server.Fqdn, directory, this.logger);
disposeGuard.Add <InjectorClient>(injectorClient);
bool flag = true;
IInjectorService injectorService = injectorClient;
if (!injectorClient.ServerVersion[1])
{
flag = false;
injectorService = this.CreateCompatibilityInjectorClient(server);
}
if (!injectorClient.ServerVersion[2])
{
injectorService = new ConsumerMetricsInjectorCapabilityDecorator(injectorService);
}
if (flag)
{
disposeGuard.Success();
}
result = injectorService;
}
return(result);
}
public Stream GetReadOnlyApplefileStream()
{
base.CheckDisposed("GetReadOnlyApplefileStream");
if (this.IsFlaggedAsMacAttachment)
{
object obj = base.TryGetProperty(InternalSchema.AttachmentMacInfo);
if (obj is byte[])
{
return(new MemoryStream(obj as byte[], false));
}
if (PropertyError.IsPropertyValueTooBig(obj))
{
return(this.OpenPropertyStream(InternalSchema.AttachmentMacInfo, PropertyOpenMode.ReadOnly));
}
using (Stream rawContentStream = this.GetRawContentStream(PropertyOpenMode.ReadOnly))
{
if (this.IsMacAttachmentInternal(rawContentStream))
{
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
Stream stream = disposeGuard.Add <MemoryStream>(new MemoryStream());
string text = null;
byte[] array = null;
MimeAppleTranscoder.MacBinToApplefile(rawContentStream, stream, out text, out array);
disposeGuard.Success();
return(stream);
}
}
throw new CorruptDataException(ServerStrings.ConversionFailedInvalidMacBin);
}
}
throw new InvalidOperationException();
}
internal BodyTextReader(ICoreItem coreItem, BodyReadConfiguration configuration, Stream inputStream)
{
using (DisposeGuard disposeGuard = this.Guard())
{
Stream stream = null;
TextReader textReader = null;
bool flag = false;
this.disposeTracker = this.GetDisposeTracker();
try
{
if (inputStream == null)
{
stream = BodyReadStream.OpenBodyStream(coreItem);
inputStream = stream;
}
if (inputStream == null)
{
inputStream = Body.GetEmptyStream();
}
textReader = BodyReadDelegates.CreateReader(coreItem, configuration, inputStream, out this.conversionCallbacks);
flag = true;
}
finally
{
if (!flag && stream != null)
{
stream.Dispose();
}
}
this.reader = textReader;
this.bodyStream = stream;
this.isDisposed = false;
disposeGuard.Success();
}
}
public static MessageItem CreateDelegateForward(MessageItem originalItem, CultureInfo culture, string imceaDomain, string xLoop, IRuleEvaluationContext context)
{
Util.ThrowOnNullArgument(originalItem, "originalItem");
ExTraceGlobals.StorageTracer.Information(0L, "RuleMessageUtils::CreateDelegateForward.");
MessageItem result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
MessageItem messageItem = RuleMessageUtils.CreateRedirect(originalItem, culture, imceaDomain, xLoop, context);
disposeGuard.Add <MessageItem>(messageItem);
for (int i = 0; i < RuleMessageUtils.rcvdRepresentingProps.Length; i++)
{
if (originalItem.GetValueOrDefault <object>(RuleMessageUtils.rcvdRepresentingProps[i]) == null)
{
object valueOrDefault = originalItem.GetValueOrDefault <object>(RuleMessageUtils.rcvdByProps[i]);
if (valueOrDefault != null)
{
messageItem[RuleMessageUtils.rcvdRepresentingProps[i]] = valueOrDefault;
}
}
messageItem.Delete(RuleMessageUtils.rcvdByProps[i]);
}
object valueOrDefault2 = originalItem.GetValueOrDefault <object>(InternalSchema.SentRepresentingEntryId);
if (valueOrDefault2 != null)
{
messageItem[InternalSchema.ReadReceiptEntryId] = valueOrDefault2;
messageItem[InternalSchema.ReportEntryId] = valueOrDefault2;
}
disposeGuard.Success();
result = messageItem;
}
return(result);
}
internal static ActivityScope AddActivityScope(ActivityContextState activityContextState)
{
Guid guid = Guid.NewGuid();
ActivityScope result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
try
{
ActivityScopeImpl.scopeCacheLock.EnterWriteLock();
ActivityScopeImpl activityScopeImpl = new ActivityScopeImpl(guid);
disposeGuard.Add <ActivityScopeImpl>(activityScopeImpl);
ActivityScopeImpl.scopeCache.Add(guid, activityScopeImpl);
ActivityScope activityScope = new ActivityScope(activityScopeImpl);
disposeGuard.Add <ActivityScope>(activityScope);
activityScopeImpl.UpdateFromState(activityContextState);
SingleContext.Singleton.LocalId = new Guid?(guid);
SingleContext.Singleton.SetId();
disposeGuard.Success();
result = activityScope;
}
finally
{
try
{
ActivityScopeImpl.scopeCacheLock.ExitWriteLock();
}
catch (SynchronizationLockException)
{
}
}
}
return(result);
}
public static RightsManagedMessageItem ReBind(MessageItem item, OutboundConversionOptions options, bool acquireLicense)
{
Util.ThrowOnNullArgument(item, "item");
Util.ThrowOnNullArgument(options, "options");
StoreSession storeSession = item.Session ?? ((item.CoreItem.TopLevelItem != null) ? item.CoreItem.TopLevelItem.Session : null);
if (storeSession == null)
{
throw new ArgumentException("Cannot use ReBind() for in-memory message.", "item");
}
RightsManagedMessageItem.CheckSession(storeSession);
if (!item.IsRestricted)
{
throw new ArgumentException("Only protected messages can be used for ReBind()");
}
RightsManagedMessageItem result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
RightsManagedMessageItem rightsManagedMessageItem = new RightsManagedMessageItem(new CoreItemWrapper(item.CoreItem));
disposeGuard.Add <RightsManagedMessageItem>(rightsManagedMessageItem);
rightsManagedMessageItem.Decode(options, acquireLicense);
disposeGuard.Success();
rightsManagedMessageItem.originalItem = item;
result = rightsManagedMessageItem;
}
return(result);
}
// Token: 0x06001173 RID: 4467 RVA: 0x0006987C File Offset: 0x00067A7C
internal OwaStoreObjectIdSessionHandle(ExchangePrincipal exchangePrincipal, UserContext userContext)
{
using (DisposeGuard disposeGuard = this.Guard())
{
if (exchangePrincipal == null)
{
throw new ArgumentNullException("exchangePrincipal");
}
if (userContext == null)
{
throw new ArgumentNullException("userContext");
}
if (exchangePrincipal.MailboxInfo.IsArchive)
{
throw new ArgumentException("exchangePrincipal is archive mailbox");
}
if (exchangePrincipal.MailboxInfo.IsAggregated)
{
throw new ArgumentException("exchangePrincipal is aggregated mailbox");
}
this.owaStoreObjectId = null;
this.userContext = userContext;
this.owaStoreObjectIdType = OwaStoreObjectIdType.OtherUserMailboxObject;
this.InitializeDelegateSessionHandle(exchangePrincipal, userContext);
disposeGuard.Success();
}
}
// Token: 0x06001174 RID: 4468 RVA: 0x00069928 File Offset: 0x00067B28
internal OwaStoreObjectIdSessionHandle(OwaStoreObjectId owaStoreObjectId, UserContext userContext)
{
using (DisposeGuard disposeGuard = this.Guard())
{
if (owaStoreObjectId == null)
{
throw new ArgumentNullException("owaStoreObjectId");
}
if (userContext == null)
{
throw new ArgumentNullException("userContext");
}
this.owaStoreObjectId = owaStoreObjectId;
this.userContext = userContext;
this.owaStoreObjectIdType = owaStoreObjectId.OwaStoreObjectIdType;
if (owaStoreObjectId.OwaStoreObjectIdType == OwaStoreObjectIdType.OtherUserMailboxObject || owaStoreObjectId.OwaStoreObjectIdType == OwaStoreObjectIdType.GSCalendar)
{
ExchangePrincipal exchangePrincipal = null;
if (!userContext.DelegateSessionManager.TryGetExchangePrincipal(owaStoreObjectId.MailboxOwnerLegacyDN, out exchangePrincipal))
{
throw new ObjectNotFoundException(ServerStrings.CannotFindExchangePrincipal);
}
this.InitializeDelegateSessionHandle(exchangePrincipal, userContext);
}
disposeGuard.Success();
}
}
protected XsoMailboxDataProviderBase(ExchangePrincipal mailboxOwner, ISecurityAccessToken userToken, string action)
{
using (DisposeGuard disposeGuard = this.Guard())
{
Util.ThrowOnNullArgument(mailboxOwner, "mailboxOwner");
Util.ThrowOnNullOrEmptyArgument(action, "action");
if (userToken == null)
{
this.MailboxSession = MailboxSession.Open(mailboxOwner, new WindowsPrincipal(WindowsIdentity.GetCurrent()), CultureInfo.InvariantCulture, string.Format("Client=Management;Action={0}", action));
}
else
{
try
{
using (ClientSecurityContext clientSecurityContext = new ClientSecurityContext(userToken, AuthzFlags.AuthzSkipTokenGroups))
{
clientSecurityContext.SetSecurityAccessToken(userToken);
this.MailboxSession = MailboxSession.Open(mailboxOwner, clientSecurityContext, CultureInfo.InvariantCulture, string.Format("Client=Management;Action={0}", action));
}
}
catch (AuthzException ex)
{
throw new AccessDeniedException(new LocalizedString(ex.Message));
}
}
disposeGuard.Success();
}
}
// Token: 0x06000314 RID: 788 RVA: 0x000137EC File Offset: 0x000119EC
private RfriStatus EndWrapper(string methodName, ICancelableAsyncResult asyncResult, Func <RfriDispatchTask, RfriStatus> endDelegate)
{
RfriStatus rfriStatus = RfriStatus.Success;
RfriAsyncDispatch.ConditionalExceptionWrapper(ExTraceGlobals.ReferralTracer.IsTraceEnabled(TraceType.DebugTrace), delegate
{
DispatchTaskAsyncResult dispatchTaskAsyncResult = asyncResult as DispatchTaskAsyncResult;
if (dispatchTaskAsyncResult != null)
{
RfriDispatchTask rfriDispatchTask = (RfriDispatchTask)dispatchTaskAsyncResult.DispatchTask;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
disposeGuard.Add <RfriDispatchTask>(rfriDispatchTask);
rfriStatus = endDelegate(rfriDispatchTask);
}
ExTraceGlobals.ReferralTracer.TraceDebug <string, RfriStatus>(0, 0L, "{0} succeeded. RfriStatus={1}.", methodName, rfriStatus);
return;
}
FailureAsyncResult <RfriStatus> failureAsyncResult = asyncResult as FailureAsyncResult <RfriStatus>;
if (failureAsyncResult != null)
{
rfriStatus = failureAsyncResult.ErrorCode;
ExTraceGlobals.ReferralTracer.TraceDebug <string, RfriStatus, Exception>(0, 0L, "{0} failed. RfriStatus={1}. Exception={2}.", methodName, rfriStatus, failureAsyncResult.Exception);
return;
}
throw new InvalidOperationException(string.Format("Invalid IAsyncResult encountered; {0}", asyncResult));
}, delegate(Exception exception)
{
ExTraceGlobals.ReferralTracer.TraceDebug <string, Exception>(0, 0L, "{0} failed. Exception={1}.", methodName, exception);
});
return(rfriStatus);
}
public override IAttachment Read(string attachmentId)
{
IList <AttachmentId> attachmentIds = IdConverter.GetAttachmentIds(attachmentId);
IAttachment result;
using (IItem item = this.BindToParentItem())
{
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
IItem item2 = item;
Attachment attachment = null;
for (int i = 0; i < attachmentIds.Count; i++)
{
attachment = IrmUtils.GetAttachmentCollection(item2).Open(attachmentIds[i]);
disposeGuard.Add <Attachment>(attachment);
if (i < attachmentIds.Count - 1)
{
if (!(attachment is ItemAttachment))
{
throw new CorruptDataException(Strings.ErrorAllButLastNestedAttachmentMustBeItemAttachment);
}
ItemAttachment itemAttachment = attachment as ItemAttachment;
item2 = itemAttachment.GetItem();
disposeGuard.Add <IItem>(item2);
}
}
StorageTranslator <IAttachment, IAttachment> attachmentTranslator = this.GetAttachmentTranslator(attachment.AttachmentType, false);
IAttachment attachment2 = attachmentTranslator.ConvertToEntity(attachment);
attachment2.Id = attachmentId;
result = attachment2;
}
}
return(result);
}
// Token: 0x06000310 RID: 784 RVA: 0x000132E8 File Offset: 0x000114E8
private static RfriContext CreateRfriContext(ClientBinding clientBinding)
{
RfriContext rfriContext = null;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
ClientSecurityContext clientSecurityContext = null;
bool isAnonymous = false;
string text = null;
string userDomain = null;
RpcHttpConnectionProperties rpcHttpConnectionProperties = null;
if (!RpcDispatch.TryGetAuthContextInfo(clientBinding, out clientSecurityContext, out isAnonymous, out text, out userDomain, out rpcHttpConnectionProperties))
{
ExTraceGlobals.ReferralTracer.TraceError <Guid>(0L, "Could not resolve anonymous user for session id: {0}", clientBinding.AssociationGuid);
throw new RfriException(RfriStatus.LogonFailed, "Could not resolve anonymous user.");
}
disposeGuard.Add <ClientSecurityContext>(clientSecurityContext);
Guid empty = Guid.Empty;
if (rpcHttpConnectionProperties != null && rpcHttpConnectionProperties.RequestIds.Length > 0)
{
Guid.TryParse(rpcHttpConnectionProperties.RequestIds[rpcHttpConnectionProperties.RequestIds.Length - 1], out empty);
}
rfriContext = new RfriContext(clientSecurityContext, userDomain, clientBinding.ClientAddress, clientBinding.ServerAddress, clientBinding.ProtocolSequence, clientBinding.AuthenticationType.ToString(), clientBinding.IsEncrypted, isAnonymous, empty);
disposeGuard.Add <RfriContext>(rfriContext);
if (!rfriContext.TryAcquireBudget())
{
ExTraceGlobals.ReferralTracer.TraceError((long)rfriContext.ContextHandle, "Could not acquire budget");
throw new RfriException(RfriStatus.GeneralFailure, "Failed to acquire budget.");
}
disposeGuard.Success();
}
return(rfriContext);
}
public PersistablePropertyBag CreateAttachment(ICollection <PropertyDefinition> propertiesToLoad, CoreAttachment attachmentToClone, IItem itemToAttach, out int attachmentNumber)
{
this.CheckDisposed(null);
InMemoryPersistablePropertyBag inMemoryPersistablePropertyBag = new InMemoryPersistablePropertyBag(propertiesToLoad);
inMemoryPersistablePropertyBag.ExTimeZone = this.ExTimeZone;
if (attachmentToClone != null)
{
throw new NotSupportedException("CreateAttachment for copied attachments is not supported");
}
attachmentNumber = this.attachmentCounter++;
inMemoryPersistablePropertyBag[InternalSchema.AttachNum] = attachmentNumber;
this.newAttachmentList.Add(attachmentNumber, inMemoryPersistablePropertyBag);
if (itemToAttach != null)
{
string text = itemToAttach.TryGetProperty(InternalSchema.ItemClass) as string;
Schema schema = (text != null) ? ObjectClass.GetSchema(text) : ItemSchema.Instance;
propertiesToLoad = InternalSchema.Combine <PropertyDefinition>(schema.AutoloadProperties, propertiesToLoad);
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
PersistablePropertyBag persistablePropertyBag = new InMemoryPersistablePropertyBag(propertiesToLoad);
disposeGuard.Add <PersistablePropertyBag>(persistablePropertyBag);
persistablePropertyBag.ExTimeZone = this.ExTimeZone;
CoreItem coreItem = new CoreItem(null, persistablePropertyBag, null, null, Origin.New, ItemLevel.Attached, propertiesToLoad, ItemBindOption.LoadRequiredPropertiesOnly);
disposeGuard.Add <CoreItem>(coreItem);
CoreItem.CopyItemContent(itemToAttach.CoreItem, coreItem);
this.attachedItems.Add(attachmentNumber, coreItem);
disposeGuard.Success();
}
}
return(inMemoryPersistablePropertyBag);
}
private void VerifyLegacyPublicFolderDatabaseLocked()
{
PublicFolderEndpoint publicFolderEndpoint = (PublicFolderEndpoint)this.DataObject.SourceEndpoint;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
IMailbox mailbox;
if (publicFolderEndpoint != null)
{
mailbox = disposeGuard.Add <IMailbox>(publicFolderEndpoint.ConnectToSourceDatabase());
}
else
{
DatabaseIdParameter id = DatabaseIdParameter.Parse(this.DataObject.SourcePublicFolderDatabase);
PublicFolderDatabase publicFolderDatabase = (PublicFolderDatabase)base.GetDataObject <PublicFolderDatabase>(id, this.ConfigurationSession, null, new LocalizedString?(Strings.ErrorDatabaseNotFound(this.DataObject.SourcePublicFolderDatabase)), new LocalizedString?(Strings.ErrorDatabaseNotUnique(this.DataObject.SourcePublicFolderDatabase)));
mailbox = disposeGuard.Add <IMailbox>(PublicFolderEndpoint.ConnectToLocalSourceDatabase(publicFolderDatabase.ExchangeObjectId));
}
try
{
bool flag;
mailbox.SetInTransitStatus(InTransitStatus.MoveSource, out flag);
mailbox.SetInTransitStatus(InTransitStatus.NotInTransit, out flag);
}
catch (SourceMailboxAlreadyBeingMovedTransientException)
{
base.WriteError(new MigrationBatchCannotBeCompletedException(Strings.CompletePublicFolderMigrationBatchRequiresSourceLockDown));
}
}
}
private static CalendarGroup CreateMyCalendarsGroup(MailboxSession session)
{
CalendarGroup calendarGroup = null;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
calendarGroup = CalendarGroup.InternalCreateGroup(session, CalendarGroupType.MyCalendars);
disposeGuard.Add <CalendarGroup>(calendarGroup);
using (CalendarGroupEntry calendarGroupEntry = CalendarGroupEntry.Create(session, session.GetDefaultFolderId(DefaultFolderType.Calendar), FolderTreeData.MyFoldersClassId, calendarGroup.GroupName))
{
calendarGroupEntry.CalendarName = ClientStrings.Calendar.ToString(session.InternalCulture);
ConflictResolutionResult conflictResolutionResult = calendarGroupEntry.Save(SaveMode.NoConflictResolution);
if (conflictResolutionResult.SaveStatus != SaveResult.Success)
{
ExTraceGlobals.StorageTracer.TraceWarning <SmtpAddress>(0L, "Unable to associate default calendar with the MyCalendars group for user: {0}. Attempting to delete default calendars group.", session.MailboxOwner.MailboxInfo.PrimarySmtpAddress);
AggregateOperationResult aggregateOperationResult = session.Delete(DeleteItemFlags.HardDelete, new StoreId[]
{
calendarGroup.Id
});
if (aggregateOperationResult.OperationResult != OperationResult.Succeeded)
{
ExTraceGlobals.StorageTracer.TraceWarning <SmtpAddress>(0L, "Unable to delete default calendar group after failing to add the default calendar to it. User: {0}", session.MailboxOwner.MailboxInfo.PrimarySmtpAddress);
}
throw new DefaultCalendarNodeCreationException();
}
}
disposeGuard.Success();
}
return(calendarGroup);
}
private static Folder GetFolder(AnchorContext context, MailboxSession mailboxSession, StoreObjectId rootFolderId, string folderName)
{
AnchorUtil.ThrowOnNullArgument(mailboxSession, "mailboxSession");
AnchorUtil.ThrowOnNullArgument(rootFolderId, "rootFolderId");
AnchorUtil.ThrowOnNullArgument(folderName, "folderName");
Folder result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
Folder folder = null;
StoreObjectId storeObjectId = AnchorFolder.GetFolderId(context, mailboxSession, rootFolderId, folderName);
if (storeObjectId == null)
{
folder = Folder.Create(mailboxSession, rootFolderId, StoreObjectType.Folder, folderName, CreateMode.OpenIfExists);
disposeGuard.Add <Folder>(folder);
folder.Save();
folder.Load(AnchorFolder.FolderIdPropertyDefinition);
storeObjectId = folder.Id.ObjectId;
}
if (folder == null)
{
folder = Folder.Bind(mailboxSession, storeObjectId, AnchorFolder.FolderIdPropertyDefinition);
disposeGuard.Add <Folder>(folder);
}
disposeGuard.Success();
result = folder;
}
return(result);
}
// Token: 0x06000714 RID: 1812 RVA: 0x00015830 File Offset: 0x00013A30
internal void CompleteBuilding()
{
try
{
Monitor.Enter(this.lockObject);
ExAssert.RetailAssert(this.state == SessionDataCacheState.Building || this.state == SessionDataCacheState.Obsolete, "Ready building session data in an invalid state: " + this.state);
if (this.state == SessionDataCacheState.Obsolete)
{
this.InternalDispose(true);
}
else
{
this.lastSessionDataBuildEndTime = ExDateTime.Now;
this.state = SessionDataCacheState.Ready;
this.signalEvent.Set();
Timer staleTimer = null;
staleTimer = new Timer(delegate(object param0)
{
this.Dispose();
DisposeGuard.DisposeIfPresent(staleTimer);
}, null, SessionDataCache.FreshnessTime, Timeout.InfiniteTimeSpan);
}
}
finally
{
if (Monitor.IsEntered(this.lockObject))
{
Monitor.Exit(this.lockObject);
}
ExTraceGlobals.SessionDataHandlerTracer.TraceDebug((long)this.GetHashCode(), string.Format("[SessionDataCache] Ready building session data cache. StartTime = {0}, EndTime = {1}, state = {2}", this.lastSessionDataBuildStartTime.ToString(), this.lastSessionDataBuildEndTime.ToString(), this.state));
OwaSingleCounters.SessionDataCacheBuildsCompleted.Increment();
}
}
internal CoreObject(StoreSession session, PersistablePropertyBag propertyBag, StoreObjectId storeObjectId, byte[] changeKey, Origin origin, ItemLevel itemLevel, ICollection <PropertyDefinition> prefetchProperties)
{
using (DisposeGuard disposeGuard = this.Guard())
{
this.session = session;
this.propertyBag = propertyBag;
this.itemLevel = itemLevel;
this.Origin = origin;
if (propertyBag.DisposeTracker != null)
{
propertyBag.DisposeTracker.AddExtraDataWithStackTrace("CoreObject owns PersistablePropertyBag propertyBag at");
}
((IDirectPropertyBag)CoreObject.GetPersistablePropertyBag(this)).Context.CoreObject = this;
((IDirectPropertyBag)CoreObject.GetPersistablePropertyBag(this)).Context.Session = this.Session;
if (prefetchProperties != null)
{
if (prefetchProperties == CoreObjectSchema.AllPropertiesOnStore)
{
this.propertyBag.PrefetchPropertyArray = CoreObjectSchema.AllPropertiesOnStore;
}
else
{
this.propertyBag.PrefetchPropertyArray = StorePropertyDefinition.GetNativePropertyDefinitions <PropertyDefinition>(PropertyDependencyType.AllRead, prefetchProperties).ToArray <NativeStorePropertyDefinition>();
}
this.propertyBag.Load(prefetchProperties);
}
this.storeObjectId = storeObjectId;
this.id = ((changeKey != null) ? new VersionedId(this.storeObjectId, changeKey) : null);
disposeGuard.Success();
}
}
private static BodyReadStream InternalTryCreateBodyStream(ICoreItem coreItem, BodyReadConfiguration configuration, bool createEmtpyStreamIfNotFound, long?length)
{
BodyReadStream result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
Stream stream = BodyReadStream.OpenBodyStream(coreItem);
disposeGuard.Add <Stream>(stream);
Stream stream2 = stream;
if (stream2 == null)
{
if (!createEmtpyStreamIfNotFound)
{
return(null);
}
stream2 = Body.GetEmptyStream();
}
ConversionCallbackBase conversionCallbackBase;
Stream disposable = BodyReadDelegates.CreateStream(coreItem, configuration, stream2, out conversionCallbackBase);
disposeGuard.Add <Stream>(disposable);
BodyReadStream bodyReadStream = new BodyReadStream(stream, disposable, conversionCallbackBase, length);
disposeGuard.Add <BodyReadStream>(bodyReadStream);
disposeGuard.Success();
result = bodyReadStream;
}
return(result);
}
Stream ISupportMime.GetMimeStream(MessageRec message, out PropValueData[] extraPropValues)
{
extraPropValues = null;
Properties properties = this.FetchMessageItem(message);
if (properties == null || properties.Body == null || string.IsNullOrEmpty(properties.Body.Data))
{
throw new UnableToFetchMimeStreamException(EasMailbox.GetStringId(message.EntryId));
}
if (properties.Flag != null)
{
extraPropValues = new PropValueData[]
{
new PropValueData((PropTag)277872643U, properties.Flag.Status)
};
}
string data = properties.Body.Data;
MemoryStream memoryStream = new MemoryStream(data.Length);
Stream result;
using (DisposeGuard disposeGuard = memoryStream.Guard())
{
using (StreamWriter streamWriter = new StreamWriter(memoryStream, Encoding.UTF8, 1024, true))
{
streamWriter.Write(data);
}
memoryStream.Seek(0L, SeekOrigin.Begin);
disposeGuard.Success();
result = memoryStream;
}
return(result);
}
public override Stream OpenPropertyStream(PropertyDefinition propertyDefinition, PropertyOpenMode openMode)
{
base.CheckDisposed("OpenPropertyStream");
EnumValidator.AssertValid <PropertyOpenMode>(openMode);
NativeStorePropertyDefinition nativeStorePropertyDefinition = propertyDefinition as NativeStorePropertyDefinition;
if (nativeStorePropertyDefinition == null)
{
throw new InvalidOperationException(ServerStrings.ExPropertyNotStreamable(propertyDefinition.ToString()));
}
Stream result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
StoreObjectStream storeObjectStream = new StoreObjectStream(this, nativeStorePropertyDefinition, openMode);
disposeGuard.Add <StoreObjectStream>(storeObjectStream);
this.listOfStreams.Add(storeObjectStream);
disposeGuard.Success();
if (openMode == PropertyOpenMode.Create || openMode == PropertyOpenMode.Modify)
{
this.TrackProperty(nativeStorePropertyDefinition, true);
}
result = storeObjectStream;
}
return(result);
}
public PublicFolderDataProvider(IConfigurationSession configurationSession, string action, Guid mailboxGuid)
{
using (DisposeGuard disposeGuard = this.Guard())
{
Util.ThrowOnNullArgument(configurationSession, "configurationSession");
Util.ThrowOnNullOrEmptyArgument(action, "action");
this.currentOrganizationId = configurationSession.GetOrgContainer().OrganizationId;
TenantPublicFolderConfiguration value = TenantPublicFolderConfigurationCache.Instance.GetValue(this.currentOrganizationId);
if (mailboxGuid == Guid.Empty)
{
Organization orgContainer = configurationSession.GetOrgContainer();
if (orgContainer.DefaultPublicFolderMailbox.HierarchyMailboxGuid != value.GetHierarchyMailboxInformation().HierarchyMailboxGuid)
{
TenantPublicFolderConfigurationCache.Instance.RemoveValue(this.currentOrganizationId);
}
}
else if (value.GetLocalMailboxRecipient(mailboxGuid) == null)
{
TenantPublicFolderConfigurationCache.Instance.RemoveValue(this.currentOrganizationId);
}
this.publicFolderSessionCache = new PublicFolderSessionCache(configurationSession.SessionSettings.CurrentOrganizationId, null, null, CultureInfo.InvariantCulture, string.Format("Client=Management;Action={0}", action), null, null, true);
this.PublicFolderSession = this.publicFolderSessionCache.GetPublicFolderSession(mailboxGuid);
disposeGuard.Success();
}
}
private ISourceMailbox GetSourceMailbox()
{
ISourceMailbox result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
ExchangePrincipal exchangePrincipal;
if (!PublicFolderSession.TryGetPublicFolderMailboxPrincipal(this.OrganizationId, PublicFolderSession.HierarchyMailboxGuidAlias, true, out exchangePrincipal))
{
throw new StoragePermanentException(PublicFolderSession.GetNoPublicFoldersProvisionedError(this.OrganizationId));
}
ISourceMailbox sourceMailbox = new RemoteSourceMailbox(exchangePrincipal.MailboxInfo.Location.ServerFqdn, null, null, this.isSingleFolderSync ? ProxyControlFlags.SkipWLMThrottling : ProxyControlFlags.None, PublicFolderSynchronizerContext.RequiredCapabilities, false, LocalMailboxFlags.None);
disposeGuard.Add <ISourceMailbox>(sourceMailbox);
TenantPartitionHint partitionHint = CommonUtils.GetPartitionHint(this.OrganizationId);
if (this.Logger != null)
{
this.Logger.LogEvent(LogEventType.Verbose, string.Format("Connecting to Primary Hierarchy. [Mailbox:{0}; Server:{1}; Database:{2}; PartitionHint:{3}]", new object[]
{
exchangePrincipal.MailboxInfo.MailboxGuid,
exchangePrincipal.MailboxInfo.Location.ServerFqdn,
exchangePrincipal.MailboxInfo.GetDatabaseGuid(),
partitionHint
}));
}
sourceMailbox.Config(null, exchangePrincipal.MailboxInfo.MailboxGuid, exchangePrincipal.MailboxInfo.MailboxGuid, partitionHint, exchangePrincipal.MailboxInfo.GetDatabaseGuid(), MailboxType.SourceMailbox, null);
sourceMailbox.Connect(MailboxConnectFlags.PublicFolderHierarchyReplication);
disposeGuard.Success();
result = sourceMailbox;
}
return(result);
}
// Token: 0x06000313 RID: 787 RVA: 0x0001366C File Offset: 0x0001186C
private ICancelableAsyncResult BeginWrapper(string methodName, CancelableAsyncCallback asyncCallback, object asyncState, ClientBinding clientBinding, string legacyDn, Func <RfriContext, RfriDispatchTask> beginDelegate)
{
ICancelableAsyncResult asyncResult = null;
RfriAsyncDispatch.ConditionalExceptionWrapper(ExTraceGlobals.ReferralTracer.IsTraceEnabled(TraceType.DebugTrace), delegate
{
if (ExTraceGlobals.ReferralTracer.IsTraceEnabled(TraceType.DebugTrace))
{
using (ClientSecurityContext clientSecurityContext = clientBinding.GetClientSecurityContext())
{
ExTraceGlobals.ReferralTracer.TraceDebug(0, 0L, "{0} started. LegacyDn={1}. ClientAddress={2}. ServerAddress={3}. ProtocolSequence={4}. EndPoint={5}. IsEncrypted={6}. ClientSecurityContext={7}.", new object[]
{
methodName,
legacyDn,
clientBinding.ClientAddress,
clientBinding.ServerAddress,
clientBinding.ProtocolSequence,
clientBinding.ClientEndpoint,
clientBinding.IsEncrypted,
clientSecurityContext
});
}
}
FailureAsyncResult <RfriStatus> failureAsyncResult = null;
this.CheckShuttingDown();
try
{
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
RfriContext rfriContext = RfriAsyncDispatch.CreateRfriContext(clientBinding);
disposeGuard.Add <RfriContext>(rfriContext);
RfriDispatchTask rfriDispatchTask = beginDelegate(rfriContext);
disposeGuard.Add <RfriDispatchTask>(rfriDispatchTask);
asyncResult = rfriDispatchTask.AsyncResult;
this.SubmitTask(rfriDispatchTask);
disposeGuard.Success();
}
}
catch (FailRpcException ex)
{
failureAsyncResult = new FailureAsyncResult <RfriStatus>((RfriStatus)ex.ErrorCode, IntPtr.Zero, ex, asyncCallback, asyncState);
asyncResult = failureAsyncResult;
}
catch (RfriException ex2)
{
failureAsyncResult = new FailureAsyncResult <RfriStatus>(ex2.Status, IntPtr.Zero, ex2, asyncCallback, asyncState);
asyncResult = failureAsyncResult;
}
if (failureAsyncResult != null && !ThreadPool.QueueUserWorkItem(RfriAsyncDispatch.FailureWaitCallback, failureAsyncResult))
{
failureAsyncResult.InvokeCallback();
}
ExTraceGlobals.ReferralTracer.TraceDebug <string>(0, 0L, "{0} succeeded.", methodName);
}, delegate(Exception exception)
{
ExTraceGlobals.ReferralTracer.TraceDebug <string, Exception>(0, 0L, "{0} failed. Exception={1}.", methodName, exception);
});
return(asyncResult);
}
internal PublishedCalendar(MailboxSession mailboxSession, StoreObjectId folderId) : base(mailboxSession, folderId)
{
using (DisposeGuard disposeGuard = this.Guard())
{
this.LoadPublishedOptions();
disposeGuard.Success();
}
}
// Token: 0x06001C0A RID: 7178 RVA: 0x0006DE44 File Offset: 0x0006C044
private static void AggregationContextRemoved(string key, object value, CacheItemRemovedReason reason)
{
if (reason == CacheItemRemovedReason.Expired)
{
ExTraceGlobals.CoreTracer.TraceWarning(0L, "an aggregation context expired before being revalidated!");
DisposeGuard.DisposeIfPresent(value as IDisposable);
}
}
// Token: 0x06000C8D RID: 3213 RVA: 0x0002E93C File Offset: 0x0002CB3C
public BrokerHandlerReferenceCounter(Func <BrokerHandler> createHandler)
{
using (DisposeGuard disposeGuard = this.Guard())
{
this.handler = createHandler();
this.handler.Subscribe();
disposeGuard.Success();
}
}
public PublicFolderStatisticsDataProvider(IConfigurationSession configurationSession, string action, Guid mailboxGuid)
{
using (DisposeGuard disposeGuard = this.Guard())
{
this.publicFolderDataProvider = new PublicFolderDataProvider(configurationSession, action, mailboxGuid);
this.mailboxGuid = mailboxGuid;
disposeGuard.Success();
}
}
// Token: 0x06000EDA RID: 3802 RVA: 0x000586E0 File Offset: 0x000568E0
public PublicFolderAssistantLogger(IPublicFolderSession publicFolderSession) : base(publicFolderSession, "PublicFolderAssistantInfo", "PublicFolderLastAssistantCycleLog", null)
{
this.logComponent = "PublicFolderAssistantLog";
this.logSuffixName = "PublicFolderAssistantLog";
using (DisposeGuard disposeGuard = this.Guard())
{
base.LogEvent(LogEventType.Entry, "Start");
disposeGuard.Success();
}
}
