// Token: 0x06000C3F RID: 3135 RVA: 0x000403BC File Offset: 0x0003E5BC
public void BuildErrorResponse(string statusCode, XmlNode responseNode, ProtocolLogger protocolLogger)
{
if (protocolLogger != null)
{
protocolLogger.IncrementValue(ProtocolLoggerData.IOFetchItemErrors);
}
XmlNode xmlNode = responseNode.OwnerDocument.CreateElement("Fetch", "ItemOperations:");
XmlNode xmlNode2 = responseNode.OwnerDocument.CreateElement("Status", "ItemOperations:");
xmlNode2.InnerText = statusCode;
xmlNode.AppendChild(xmlNode2);
if (!string.IsNullOrEmpty(this.longId))
{
XmlNode xmlNode3 = responseNode.OwnerDocument.CreateElement("LongId", "Search:");
xmlNode3.InnerText = this.longId;
xmlNode.AppendChild(xmlNode3);
}
if (!string.IsNullOrEmpty(this.collectionId))
{
XmlNode xmlNode4 = responseNode.OwnerDocument.CreateElement("CollectionId", "AirSync:");
xmlNode4.InnerText = this.collectionId;
xmlNode.AppendChild(xmlNode4);
}
if (!string.IsNullOrEmpty(this.serverId))
{
XmlNode xmlNode5 = responseNode.OwnerDocument.CreateElement("ServerId", "AirSync:");
xmlNode5.InnerText = this.serverId;
xmlNode.AppendChild(xmlNode5);
}
responseNode.AppendChild(xmlNode);
}
public void BuildErrorResponse(string statusCode, XmlNode responseNode, ProtocolLogger protocolLogger)
{
if (protocolLogger != null)
{
protocolLogger.IncrementValue(ProtocolLoggerData.IOMoveErrors);
}
this.BuildResponseWithStatus(statusCode, responseNode);
}
private static void AppendToLog(StringBuilder logString, string prefix, object objectToLog)
{
if (objectToLog == null)
{
return;
}
ProtocolLogger.AppendToLogInternal(logString, prefix, objectToLog);
}
// Token: 0x060000B6 RID: 182 RVA: 0x000077F0 File Offset: 0x000059F0
private static void ReadStaticADData(ProtocolLogger logger)
{
if (!ADDeviceManager.initialized)
{
lock (ADDeviceManager.syncLock)
{
if (!ADDeviceManager.initialized)
{
ITopologyConfigurationSession configSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 587, "ReadStaticADData", "f:\\15.00.1497\\sources\\dev\\AirSync\\src\\AirSync\\ADDeviceManager.cs");
configSession.UseConfigNC = false;
configSession.UseGlobalCatalog = true;
ADGroup exchangeServersGroup = null;
ADNotificationAdapter.RunADOperation(delegate()
{
exchangeServersGroup = configSession.ResolveWellKnownGuid <ADGroup>(WellKnownGuid.ExSWkGuid, configSession.ConfigurationNamingContext);
});
if (exchangeServersGroup == null)
{
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.ServerError, EASServerStrings.FailedToResolveWellKnownGuid(WellKnownGuid.ExSWkGuid.ToString(), "Exchange Server Security Group"), true)
{
ErrorStringForProtocolLogger = "ExSrvGrpSchemaGuidNotFound"
};
}
ADDeviceManager.exchangeServersGroupSid = exchangeServersGroup.Sid;
if (logger != null)
{
logger.SetValue(ProtocolLoggerData.DomainController, configSession.LastUsedDc);
}
configSession.UseGlobalCatalog = false;
ADSchemaClassObject[] objClass = null;
ADNotificationAdapter.RunADOperation(delegate()
{
objClass = configSession.Find <ADSchemaClassObject>(configSession.SchemaNamingContext, QueryScope.OneLevel, new ComparisonFilter(ComparisonOperator.Equal, ADSchemaObjectSchema.DisplayName, "msExchActiveSyncDevice"), ADDeviceManager.defaultSortOrder, 2);
});
if (objClass == null || objClass.Length == 0 || objClass[0].SchemaIDGuid == Guid.Empty)
{
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.ServerError, EASServerStrings.CannotFindSchemaClassException("msExchActiveSyncDevice", configSession.SchemaNamingContext.DistinguishedName), true);
}
if (objClass.Length > 1 && logger != null)
{
logger.SetValue(ProtocolLoggerData.Error, "DisplayNameIsNotUniqueForClassMsExchActiveSyncDevice");
}
ADDeviceManager.activeSyncDeviceClass = objClass[0].SchemaIDGuid;
if (logger != null)
{
logger.SetValue(ProtocolLoggerData.DomainController, configSession.LastUsedDc);
}
ADDeviceManager.initialized = true;
}
}
}
}
internal static ActiveSyncMiniRecipient TryGetADUser(IAirSyncUser user, ProtocolLogger logger)
{
ADUserCache.< > c__DisplayClass1 CS$ < > 8__locals1 = new ADUserCache.< > c__DisplayClass1();
AirSyncDiagnostics.Assert(user != null, "IAirSyncUser cannot be null in GetADUser", new object[0]);
CS$ < > 8__locals1.sid2 = user.ClientSecurityContextWrapper.UserSid;
ActiveSyncMiniRecipient activeSyncMiniRecipient = null;
if (!GlobalSettings.DisableCaching && ADUserCache.TryGetADUser(CS$ < > 8__locals1.sid2.Value, out activeSyncMiniRecipient))
{
return(activeSyncMiniRecipient);
}
string value = user.Name;
if (GlobalSettings.IsWindowsLiveIDEnabled)
{
value = user.WindowsLiveId;
}
if (string.IsNullOrEmpty(value))
{
logger.SetValue(ProtocolLoggerData.Error, "BadAuthUsername");
throw new AirSyncPermanentException(HttpStatusCode.BadRequest, StatusCode.InvalidCombinationOfIDs, null, false);
}
AirSyncDiagnostics.TraceDebug <string>(ExTraceGlobals.RequestsTracer, null, "ADUserCache.TryGetADUser:: user IdentityType {0}", user.Identity.GetType().FullName);
ADSessionSettings sessionSettings = ADUserCache.GetSessionSettings(GlobalSettings.IsMultiTenancyEnabled ? (user.Identity as LiveIDIdentity).UserOrganizationId : OrganizationId.ForestWideOrgId, logger);
IRecipientSession recipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(null, null, 0, true, ConsistencyMode.IgnoreInvalid, null, sessionSettings, 124, "TryGetADUser", "f:\\15.00.1497\\sources\\dev\\AirSync\\src\\AirSync\\ADUserCache.cs");
ActiveSyncMiniRecipient recipient = null;
ADNotificationAdapter.RunADOperation(delegate()
{
recipient = recipientSession.FindMiniRecipientBySid <ActiveSyncMiniRecipient>(CS$ < > 8__locals1.sid2, ObjectSchema.GetInstance <ClientAccessRulesRecipientFilterSchema>().AllProperties);
});
logger.SetValue(ProtocolLoggerData.DomainController, recipientSession.LastUsedDc);
if (recipient == null)
{
AirSyncDiagnostics.TraceDebug <SecurityIdentifier>(ExTraceGlobals.RequestsTracer, null, "ADUserCache.TryGetADUserFromSid can't find ActiveSyncMiniRecipient for sid {0}", CS$ < > 8__locals1.sid2);
return(null);
}
activeSyncMiniRecipient = ((recipient.RecipientType == RecipientType.UserMailbox || recipient.RecipientType == RecipientType.MailUser) ? recipient : null);
if (activeSyncMiniRecipient == null)
{
AirSyncDiagnostics.TraceDebug <RecipientType>(ExTraceGlobals.RequestsTracer, null, "ADUserCache.TryGetADUserFromSid recipient type is {0} when expected UserMailbox/MailUser", recipient.RecipientType);
return(null);
}
if (!GlobalSettings.DisableCaching)
{
ADUserCache.AddADUserToCache(CS$ < > 8__locals1.sid2.Value, activeSyncMiniRecipient);
}
return(activeSyncMiniRecipient);
}
internal static ADSessionSettings GetSessionSettings(OrganizationId orgId, ProtocolLogger logger)
{
AirSyncDiagnostics.Assert(orgId != null);
if (GlobalSettings.IsMultiTenancyEnabled)
{
AirSyncDiagnostics.TraceDebug <string>(ExTraceGlobals.RequestsTracer, null, "organizationID :{0}", orgId.ToString());
ADSessionSettings result = null;
ADNotificationAdapter.RunADOperation(delegate()
{
result = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(orgId);
});
return(result);
}
return(ADSessionSettings.FromRootOrgScopeSet());
}
// Token: 0x0600075E RID: 1886 RVA: 0x00028EA8 File Offset: 0x000270A8
public void BuildErrorResponse(string statusCode, XmlNode responseNode, ProtocolLogger protocolLogger)
{
if (protocolLogger != null)
{
protocolLogger.IncrementValue(ProtocolLoggerData.IOEmptyFolderContentsErrors);
}
XmlNode xmlNode = responseNode.OwnerDocument.CreateElement("EmptyFolderContents", "ItemOperations:");
XmlNode xmlNode2 = responseNode.OwnerDocument.CreateElement("Status", "ItemOperations:");
xmlNode2.InnerText = statusCode;
xmlNode.AppendChild(xmlNode2);
if (!string.IsNullOrEmpty(this.folderId))
{
XmlNode xmlNode3 = responseNode.OwnerDocument.CreateElement("CollectionId", "AirSync:");
xmlNode3.InnerText = this.folderId;
xmlNode.AppendChild(xmlNode3);
}
responseNode.AppendChild(xmlNode);
}
public void BuildErrorResponse(string statusCode, XmlNode responseNode, ProtocolLogger protocolLogger)
{
if (protocolLogger != null)
{
protocolLogger.IncrementValue(ProtocolLoggerData.IOFetchAttErrors);
}
XmlNode xmlNode = responseNode.OwnerDocument.CreateElement("Fetch", "ItemOperations:");
XmlNode xmlNode2 = responseNode.OwnerDocument.CreateElement("Status", "ItemOperations:");
xmlNode2.InnerText = statusCode;
xmlNode.AppendChild(xmlNode2);
if (!string.IsNullOrEmpty(this.FileReference))
{
XmlNode xmlNode3 = responseNode.OwnerDocument.CreateElement("FileReference", "AirSyncBase:");
xmlNode3.InnerText = this.FileReference;
xmlNode.AppendChild(xmlNode3);
}
responseNode.AppendChild(xmlNode);
}
// Token: 0x0600074F RID: 1871 RVA: 0x00028B20 File Offset: 0x00026D20
public void BuildErrorResponse(string statusCode, XmlNode responseNode, ProtocolLogger protocolLogger)
{
if (protocolLogger != null)
{
protocolLogger.IncrementValue(ProtocolLoggerData.IOFetchDocErrors);
}
XmlNode xmlNode = responseNode.OwnerDocument.CreateElement("Fetch", "ItemOperations:");
XmlNode xmlNode2 = responseNode.OwnerDocument.CreateElement("Status", "ItemOperations:");
xmlNode2.InnerText = statusCode;
xmlNode.AppendChild(xmlNode2);
if (!string.IsNullOrEmpty(this.linkId))
{
XmlNode xmlNode3 = responseNode.OwnerDocument.CreateElement("LinkId", "DocumentLibrary:");
xmlNode3.InnerText = this.linkId;
xmlNode.AppendChild(xmlNode3);
}
responseNode.AppendChild(xmlNode);
}
public RightsManagementInformationSetting(XmlNode request, XmlNode response, IAirSyncUser user, CultureInfo cultureInfo, ProtocolLogger protocolLogger, MailboxLogger mailboxLogger) : base(request, response, protocolLogger)
{
this.user = user;
this.cultureInfo = cultureInfo;
this.mailboxLogger = mailboxLogger;
}
public SettingsBase(XmlNode request, XmlNode response, ProtocolLogger protocolLogger)
{
this.request = request;
this.response = response;
this.protocolLogger = protocolLogger;
}
public ProxyHandler(ProtocolLogger protocolLogger)
{
this.protocolLogger = protocolLogger;
}
private static void HandleMultipleDefaultPolicies(MobileMailboxPolicy[] defaultPolicies, ADObjectId organizationalUnitRoot, ProtocolLogger protocollogger)
{
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < defaultPolicies.Length; i++)
{
if (i != 0)
{
stringBuilder.Append(",");
}
stringBuilder.Append(defaultPolicies[i].Identity);
}
AirSyncDiagnostics.LogPeriodicEvent(AirSyncEventLogConstants.Tuple_MultipleDefaultMobileMailboxPoliciesDetected, "MultipleDefaultMobileMailboxPoliciesDetected", new string[]
{
organizationalUnitRoot.Parent.Name,
stringBuilder.ToString()
});
protocollogger.SetValue(ProtocolLoggerData.Error, "MultipleDefaultPoliciesDetected");
}
// Token: 0x06000AAA RID: 2730 RVA: 0x0003B168 File Offset: 0x00039368
public static GlobalInfo LoadFromMailbox(MailboxSession mailboxSession, SyncStateStorage syncStateStorage, ProtocolLogger protocolLogger, out bool updateUserHasPartnership)
{
if (mailboxSession == null)
{
throw new ArgumentNullException("mailboxSession");
}
if (syncStateStorage == null)
{
throw new ArgumentNullException("syncStateStorage");
}
updateUserHasPartnership = false;
CustomSyncState customSyncState = null;
GlobalInfo globalInfo = null;
bool isDirty = false;
bool hasNewSyncData = false;
bool hasNewAutdData = false;
bool isSyncStateJustUpgraded = false;
bool flag = false;
GlobalInfo result;
try
{
GlobalSyncStateInfo syncStateInfo = new GlobalSyncStateInfo();
customSyncState = syncStateStorage.GetCustomSyncState(syncStateInfo, GlobalInfo.ExtraGlobalInfoPropertiesToFetch);
if (customSyncState == null)
{
isDirty = true;
using (CustomSyncState customSyncState2 = syncStateStorage.GetCustomSyncState(new FolderIdMappingSyncStateInfo(), new PropertyDefinition[0]))
{
if (customSyncState2 == null)
{
updateUserHasPartnership = true;
syncStateStorage.DeleteAllSyncStates();
}
}
customSyncState = syncStateStorage.CreateCustomSyncState(syncStateInfo);
isDirty = true;
}
else
{
try
{
object obj = customSyncState.StoreObject.TryGetProperty(AirSyncStateSchema.LastSyncAttemptTime);
hasNewSyncData = (obj != null && !(obj is PropertyError));
}
catch (Exception arg)
{
AirSyncDiagnostics.TraceError <Exception>(ExTraceGlobals.RequestsTracer, null, "[GlobalInfo.LoadFromMailbox] Encountered exception when checking for new syncStatus properties. Exception: {0}", arg);
}
try
{
object obj2 = customSyncState.StoreObject.TryGetProperty(AirSyncStateSchema.LastPingHeartbeatInterval);
hasNewAutdData = (obj2 != null && !(obj2 is PropertyError));
}
catch (Exception arg2)
{
AirSyncDiagnostics.TraceError <Exception>(ExTraceGlobals.RequestsTracer, null, "[GlobalInfo.LoadFromMailbox] Encountered exception when checking for new syncStatus properties. Exception: {0}", arg2);
}
if (customSyncState.BackendVersion != null && customSyncState.BackendVersion.Value != customSyncState.Version)
{
isDirty = true;
isSyncStateJustUpgraded = true;
if (protocolLogger != null)
{
protocolLogger.SetValue(ProtocolLoggerData.Ssu, "2007");
}
}
}
globalInfo = new GlobalInfo(customSyncState);
globalInfo.IsDirty = isDirty;
globalInfo.HasNewSyncData = hasNewSyncData;
globalInfo.HasNewAutdData = hasNewAutdData;
globalInfo.IsSyncStateJustUpgraded = isSyncStateJustUpgraded;
if (Command.CurrentCommand != null)
{
globalInfo.WriteNewSyncData = Command.CurrentCommand.User.Features.IsEnabled(EasFeature.SyncStatusOnGlobalInfo);
}
flag = true;
result = globalInfo;
}
finally
{
if (!flag)
{
if (globalInfo != null)
{
globalInfo.Dispose();
}
else if (customSyncState != null)
{
customSyncState.Dispose();
}
}
}
return(result);
}
// Token: 0x06000D6E RID: 3438 RVA: 0x00049944 File Offset: 0x00047B44
public OofSetting(XmlNode request, XmlNode response, MailboxSession mailboxSession, DeviceAccessState currentAccessState, ProtocolLogger protocolLogger) : base(request, response, protocolLogger)
{
this.mailboxSession = mailboxSession;
this.verbResponseNodes = new List <XmlNode>();
this.currentAccessState = currentAccessState;
}
private static void AppendToLog(StringBuilder logString, string flag)
{
ProtocolLogger.AppendToLogInternal(logString, flag, null);
}
internal DevicePasswordSetting(XmlNode request, XmlNode response, IAirSyncUser user, GlobalInfo globalInfo, ProtocolLogger protocolLogger) : base(request, response, protocolLogger)
{
this.user = user;
if (globalInfo == null)
{
throw new ArgumentNullException("globalInfo should not be null here!");
}
this.globalInfo = globalInfo;
}
// Token: 0x06000C3B RID: 3131 RVA: 0x00040183 File Offset: 0x0003E383
internal MailboxAttachmentFetchProvider(MailboxSession session, SyncStateStorage syncStateStorage, ProtocolLogger protocolLogger, Unlimited <ByteQuantifiedSize> maxAttachmentSize, bool attachmentsEnabled) : base(session, syncStateStorage, protocolLogger, maxAttachmentSize, attachmentsEnabled)
{
}
private static PolicyData LoadDefaultPolicySetting(IConfigurationSession scopedSession, ProtocolLogger protocolLogger)
{
MobileMailboxPolicy[] mobileMaiboxPolicies = null;
ADOperationResult adoperationResult = ADNotificationAdapter.TryRunADOperation(delegate()
{
mobileMaiboxPolicies = scopedSession.Find <MobileMailboxPolicy>(scopedSession.GetOrgContainerId().GetDescendantId(new ADObjectId("CN=Mobile Mailbox Policies")), QueryScope.OneLevel, ADNotificationManager.filter, ADNotificationManager.sortBy, 3);
});
if (!adoperationResult.Succeeded)
{
AirSyncDiagnostics.TraceDebug <ADObjectId, string>(ExTraceGlobals.RequestsTracer, null, "Exception occurred during AD Operation during LoadDefaultPolicySettings for OrgID {0}. Message - {1}", scopedSession.GetOrgContainerId(), adoperationResult.Exception.Message);
throw adoperationResult.Exception;
}
protocolLogger.SetValue(ProtocolLoggerData.DomainController, scopedSession.LastUsedDc);
if (mobileMaiboxPolicies == null || mobileMaiboxPolicies.Length == 0)
{
AirSyncDiagnostics.TraceInfo <ADObjectId>(ExTraceGlobals.RequestsTracer, null, "no default policy setting found for OrgId {0}", scopedSession.GetOrgContainerId());
return(null);
}
AirSyncDiagnostics.TraceInfo <ADObjectId>(ExTraceGlobals.RequestsTracer, null, "LoadDefaultPolicySetting from AD.Policy Id {0}", mobileMaiboxPolicies[0].Id);
if (mobileMaiboxPolicies.Length > 1)
{
ADNotificationManager.HandleMultipleDefaultPolicies(mobileMaiboxPolicies, scopedSession.GetOrgContainerId(), protocolLogger);
protocolLogger.SetValue(ProtocolLoggerData.DomainController, scopedSession.LastUsedDc);
}
return(ADNotificationManager.AddPolicyToCache(mobileMaiboxPolicies[0], scopedSession.SessionSettings.CurrentOrganizationId.PartitionId));
}
// Token: 0x06000AA9 RID: 2729 RVA: 0x0003B150 File Offset: 0x00039350
public static GlobalInfo LoadFromMailbox(MailboxSession mailboxSession, SyncStateStorage syncStateStorage, ProtocolLogger protocolLogger)
{
bool flag;
return(GlobalInfo.LoadFromMailbox(mailboxSession, syncStateStorage, protocolLogger, out flag));
}
// Token: 0x06000556 RID: 1366 RVA: 0x0001EDD0 File Offset: 0x0001CFD0
public static DeviceBehavior GetDeviceBehavior(Guid userGuid, DeviceIdentity deviceIdentity, GlobalInfo globalInfo, object traceObject, ProtocolLogger protocolLogger)
{
string token = DeviceBehaviorCache.GetToken(userGuid, deviceIdentity);
globalInfo.DeviceBehavior.ProtocolLogger = protocolLogger;
globalInfo.DeviceBehavior.CacheToken = token;
DeviceBehavior deviceBehavior;
if (globalInfo.DeviceADObjectId == null || !DeviceBehaviorCache.TryGetAndRemoveValue(userGuid, deviceIdentity, out deviceBehavior))
{
if (protocolLogger != null)
{
protocolLogger.SetValue(ProtocolLoggerData.DeviceBehaviorLoaded, 7);
}
AirSyncDiagnostics.TraceInfo(ExTraceGlobals.RequestsTracer, traceObject, "No device in cache, return GlobalInfo.DeviceBehavior");
return(globalInfo.DeviceBehavior);
}
if (deviceBehavior.AutoBlockReason != globalInfo.DeviceBehavior.AutoBlockReason)
{
if (protocolLogger != null)
{
protocolLogger.SetValue(ProtocolLoggerData.DeviceBehaviorLoaded, 1);
}
AirSyncDiagnostics.TraceInfo(ExTraceGlobals.RequestsTracer, traceObject, "AutoBlockReason changed, return GlobalInfo.DeviceBehavior");
return(globalInfo.DeviceBehavior);
}
int num = globalInfo.DeviceBehavior.IsNewerThan(deviceBehavior.WhenLoaded);
if (num > -1)
{
string arg = DeviceBehavior.dateCollections[num];
if (protocolLogger != null)
{
protocolLogger.SetValue(ProtocolLoggerData.DeviceBehaviorLoaded, num + 2);
}
AirSyncDiagnostics.TraceInfo <string>(ExTraceGlobals.RequestsTracer, traceObject, "{0} is newer, return GlobalInfo.DeviceBehavior", arg);
return(globalInfo.DeviceBehavior);
}
AirSyncDiagnostics.TraceInfo(ExTraceGlobals.RequestsTracer, traceObject, "Return cached DeviceBehavior");
deviceBehavior.Owner = globalInfo;
deviceBehavior.ProtocolLogger = protocolLogger;
return(deviceBehavior);
}
// Token: 0x060000AD RID: 173 RVA: 0x00006EF8 File Offset: 0x000050F8
internal ADDeviceManager(DeviceIdentity deviceIdentity, MobileClientType clientType, OrganizationId organizationId, string userName, ADObjectId userId, ADObject user, ProtocolLogger protocolLogger, IBudget budget, Trace tracer, ExEventLog.EventTuple unableToCreateADDeviceEventTuple, ExEventLog.EventTuple directoryAccessDeniedEventTuple)
{
ArgumentValidator.ThrowIfNull("deviceIdentity", deviceIdentity);
ArgumentValidator.ThrowIfNull("organizationId", organizationId);
ArgumentValidator.ThrowIfNull("userName", userName);
ArgumentValidator.ThrowIfNull("userId", userId);
ArgumentValidator.ThrowIfNull("user", user);
ArgumentValidator.ThrowIfNull("tracer", tracer);
this.deviceIdentity = deviceIdentity;
this.clientType = clientType;
this.organizationId = organizationId;
this.userName = userName;
this.userId = userId;
this.user = user;
this.protocolLogger = protocolLogger;
this.budget = budget;
this.tracer = tracer;
this.unableToCreateADDeviceEventTuple = unableToCreateADDeviceEventTuple;
this.directoryAccessDeniedEventTuple = directoryAccessDeniedEventTuple;
this.session = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(false, ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(this.organizationId), 219, ".ctor", "f:\\15.00.1497\\sources\\dev\\AirSync\\src\\AirSync\\ADDeviceManager.cs");
this.session.UseConfigNC = false;
this.defaultDeviceFilter = new AndFilter(new QueryFilter[]
{
new ComparisonFilter(ComparisonOperator.Equal, MobileDeviceSchema.DeviceId, this.deviceIdentity.DeviceId),
new ComparisonFilter(ComparisonOperator.Equal, MobileDeviceSchema.DeviceType, this.deviceIdentity.DeviceType),
new ComparisonFilter(ComparisonOperator.Equal, MobileDeviceSchema.ClientType, this.clientType)
});
}
public override bool GenerateResponsesXmlNode(XmlDocument xmlResponse, IAirSyncVersionFactory versionFactory, string deviceType, GlobalInfo globalInfo, ProtocolLogger protocolLogger, MailboxLogger mailboxLogger)
{
return(false);
}
public TimeZoneOffsetSettings(XmlNode request, XmlNode response, IAirSyncUser user, ProtocolLogger protocolLogger) : base(request, response, protocolLogger)
{
this.user = user;
}
internal BaseAttachmentFetchProvider(MailboxSession session, SyncStateStorage syncStateStorage, ProtocolLogger protocolLogger, Unlimited <ByteQuantifiedSize> maxAttachmentSize, bool attachmentsEnabled)
{
this.Session = session;
this.SyncStateStorage = syncStateStorage;
this.ProtocolLogger = protocolLogger;
this.MaxAttachmentSize = maxAttachmentSize;
this.AttachmentsEnabled = attachmentsEnabled;
AirSyncCounters.NumberOfMailboxAttachmentFetches.Increment();
}
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder("&Log=", 200);
ProtocolLogger.AppendToLog(stringBuilder, "PrxTo", this.storedData[ProtocolLoggerData.ProxyingTo]);
ProtocolLogger.AppendToLog(stringBuilder, "PrxFrom", this.storedData[ProtocolLoggerData.ProxyingFrom]);
ProtocolLogger.AppendToLog(stringBuilder, "RdirTo", this.storedData[ProtocolLoggerData.RedirectTo]);
ProtocolLogger.AppendToLog(stringBuilder, "PrxUser", this.storedData[ProtocolLoggerData.ProxyUser]);
ProtocolLogger.AppendToLog(stringBuilder, "V", this.storedData[ProtocolLoggerData.ProtocolVersion]);
ProtocolLogger.AppendToLog(stringBuilder, "HH", this.storedData[ProtocolLoggerData.Host]);
ProtocolLogger.AppendToLog(stringBuilder, "OlkExtHdr", this.storedData[ProtocolLoggerData.OutlookExtensionsHeader]);
ProtocolLogger.AppendToLog(stringBuilder, "SmtpAdrs", this.storedData[ProtocolLoggerData.UserSmtpAddress]);
ProtocolLogger.AppendToLog(stringBuilder, "Puid", this.storedData[ProtocolLoggerData.PUID]);
ProtocolLogger.AppendToLog(stringBuilder, "Oid", this.storedData[ProtocolLoggerData.OrganizationId]);
ProtocolLogger.AppendToLog(stringBuilder, "OrgType", this.storedData[ProtocolLoggerData.OrganizationType]);
ProtocolLogger.AppendToLog(stringBuilder, "DRmv", this.storedData[ProtocolLoggerData.NoOfDevicesRemoved]);
ProtocolLogger.AppendToLog(stringBuilder, "NMS", this.storedData[ProtocolLoggerData.NewMailboxSession]);
ProtocolLogger.AppendToLog(stringBuilder, "Ssnf", this.storedData[ProtocolLoggerData.SyncStateNotFound]);
ProtocolLogger.AppendToLog(stringBuilder, "Fc", this.storedData[ProtocolLoggerData.TotalFolders]);
if (this.storedFolders.Count <= GlobalSettings.MaxCollectionsToLog)
{
foreach (KeyValuePair <string, Hashtable> keyValuePair in this.storedFolders)
{
string key = keyValuePair.Key;
Hashtable value = keyValuePair.Value;
ProtocolLogger.AppendToLog(stringBuilder, "Fid", value[PerFolderProtocolLoggerData.FolderId]);
ProtocolLogger.AppendToLog(stringBuilder, "Ty", value[PerFolderProtocolLoggerData.FolderDataType]);
ProtocolLogger.AppendToLog(stringBuilder, "Filt", value[PerFolderProtocolLoggerData.FilterType]);
ProtocolLogger.AppendToLog(stringBuilder, "Filts", value[PerFolderProtocolLoggerData.SmsFilterType]);
ProtocolLogger.AppendToLog(stringBuilder, "St", value[PerFolderProtocolLoggerData.SyncType]);
ProtocolLogger.AppendToLog(stringBuilder, "Sk", value[PerFolderProtocolLoggerData.ClientSyncKey]);
ProtocolLogger.AppendToLog(stringBuilder, "Sks", value[PerFolderProtocolLoggerData.ServerSyncKey]);
ProtocolLogger.AppendToLog(stringBuilder, "Sst", value[PerFolderProtocolLoggerData.SyncStateKb]);
ProtocolLogger.AppendToLog(stringBuilder, "Sslc", value[PerFolderProtocolLoggerData.SyncStateKbLeftCompressed]);
ProtocolLogger.AppendToLog(stringBuilder, "SsCmt", value[PerFolderProtocolLoggerData.SyncStateKbCommitted]);
ProtocolLogger.AppendToLog(stringBuilder, "TotSvC", value[PerFolderProtocolLoggerData.TotalSaveCount]);
ProtocolLogger.AppendToLog(stringBuilder, "ColdSvC", value[PerFolderProtocolLoggerData.ColdSaveCount]);
ProtocolLogger.AppendToLog(stringBuilder, "ColdCpyC", value[PerFolderProtocolLoggerData.ColdCopyCount]);
ProtocolLogger.AppendToLog(stringBuilder, "TotLdC", value[PerFolderProtocolLoggerData.TotalLoadCount]);
ProtocolLogger.AppendToLog(stringBuilder, "MR", value[PerFolderProtocolLoggerData.MidnightRollover]);
ProtocolLogger.AppendToLog(stringBuilder, "FtsR", value[PerFolderProtocolLoggerData.FirstTimeSyncItemsDiscarded]);
ProtocolLogger.AppendToLog(stringBuilder, "ProvSyncType", value[PerFolderProtocolLoggerData.ProviderSyncType]);
ProtocolLogger.AppendToLog(stringBuilder, "GetChgsIter", value[PerFolderProtocolLoggerData.GetChangesIterations]);
ProtocolLogger.AppendToLog(stringBuilder, "GetChgsTime", value[PerFolderProtocolLoggerData.GetChangesTime]);
if (this.GetIntegerValue(key, PerFolderProtocolLoggerData.ClientAdds) != 0 || this.GetIntegerValue(key, PerFolderProtocolLoggerData.ClientChanges) != 0 || this.GetIntegerValue(key, PerFolderProtocolLoggerData.ClientDeletes) != 0 || this.GetIntegerValue(key, PerFolderProtocolLoggerData.ClientFetches) != 0 || this.GetIntegerValue(key, PerFolderProtocolLoggerData.ClientFailedToConvert) != 0 || this.GetIntegerValue(key, PerFolderProtocolLoggerData.ClientSends) != 0)
{
string objectToLog = string.Format(CultureInfo.InvariantCulture, "{0}a{1}c{2}d{3}f{4}e{5}s{6}fs", new object[]
{
this.GetIntegerValueAsObject(key, PerFolderProtocolLoggerData.ClientAdds),
this.GetIntegerValueAsObject(key, PerFolderProtocolLoggerData.ClientChanges),
this.GetIntegerValueAsObject(key, PerFolderProtocolLoggerData.ClientDeletes),
this.GetIntegerValueAsObject(key, PerFolderProtocolLoggerData.ClientFetches),
this.GetIntegerValueAsObject(key, PerFolderProtocolLoggerData.ClientFailedToConvert),
this.GetIntegerValueAsObject(key, PerFolderProtocolLoggerData.ClientSends),
this.GetIntegerValueAsObject(key, PerFolderProtocolLoggerData.ClientFailedToSend)
});
ProtocolLogger.AppendToLog(stringBuilder, "Cli", objectToLog);
}
if (this.GetIntegerValue(key, PerFolderProtocolLoggerData.ServerAdds) != 0 || this.GetIntegerValue(key, PerFolderProtocolLoggerData.ServerChanges) != 0 || this.GetIntegerValue(key, PerFolderProtocolLoggerData.ServerDeletes) != 0 || this.GetIntegerValue(key, PerFolderProtocolLoggerData.ServerSoftDeletes) != 0 || this.GetIntegerValue(key, PerFolderProtocolLoggerData.ServerFailedToConvert) != 0 || this.GetIntegerValue(key, PerFolderProtocolLoggerData.ServerAssociatedAdds) != 0)
{
string objectToLog2 = string.Format(CultureInfo.InvariantCulture, "{0}a{1}c{2}d{3}s{4}e{5}r{6}A{7}sd", new object[]
{
this.GetIntegerValueAsObject(key, PerFolderProtocolLoggerData.ServerAdds),
this.GetIntegerValueAsObject(key, PerFolderProtocolLoggerData.ServerChanges),
this.GetIntegerValueAsObject(key, PerFolderProtocolLoggerData.ServerDeletes),
this.GetIntegerValueAsObject(key, PerFolderProtocolLoggerData.ServerSoftDeletes),
this.GetIntegerValueAsObject(key, PerFolderProtocolLoggerData.ServerFailedToConvert),
this.GetIntegerValueAsObject(key, PerFolderProtocolLoggerData.ServerChangeTrackingRejected),
this.GetIntegerValueAsObject(key, PerFolderProtocolLoggerData.ServerAssociatedAdds),
this.GetIntegerValueAsObject(key, PerFolderProtocolLoggerData.SkippedDeletes)
});
ProtocolLogger.AppendToLog(stringBuilder, "Srv", objectToLog2);
}
ProtocolLogger.AppendToLog(stringBuilder, "Pfs", value[PerFolderProtocolLoggerData.PerFolderStatus]);
ProtocolLogger.AppendToLog(stringBuilder, "BR", value[PerFolderProtocolLoggerData.BodyRequested]);
ProtocolLogger.AppendToLog(stringBuilder, "BPR", value[PerFolderProtocolLoggerData.BodyPartRequested]);
}
}
ProtocolLogger.AppendToLog(stringBuilder, "E", this.storedData[ProtocolLoggerData.NumErrors]);
ProtocolLogger.AppendToLog(stringBuilder, "Io", this.storedData[ProtocolLoggerData.NumItemsOpened]);
ProtocolLogger.AppendToLog(stringBuilder, "Hb", this.storedData[ProtocolLoggerData.HeartBeatInterval]);
ProtocolLogger.AppendToLog(stringBuilder, "Rto", this.storedData[ProtocolLoggerData.RequestTimedOut]);
ProtocolLogger.AppendToLog(stringBuilder, "Hang", this.storedData[ProtocolLoggerData.RequestHangTime]);
ProtocolLogger.AppendToLog(stringBuilder, "Erq", this.storedData[ProtocolLoggerData.EmptyRequest]);
ProtocolLogger.AppendToLog(stringBuilder, "Ers", this.storedData[ProtocolLoggerData.EmptyResponse]);
ProtocolLogger.AppendToLog(stringBuilder, "Cpo", this.storedData[ProtocolLoggerData.CompletionOffset]);
ProtocolLogger.AppendToLog(stringBuilder, "Fet", this.storedData[ProtocolLoggerData.FinalElapsedTime]);
ProtocolLogger.AppendToLog(stringBuilder, "ExStk", this.storedData[ProtocolLoggerData.ExceptionStackTrace]);
ProtocolLogger.AppendToLog(stringBuilder, "Ssp", this.storedData[ProtocolLoggerData.SharePointDocs]);
ProtocolLogger.AppendToLog(stringBuilder, "Sspb", this.storedData[ProtocolLoggerData.SharePointBytes]);
ProtocolLogger.AppendToLog(stringBuilder, "Unc", this.storedData[ProtocolLoggerData.UNCFiles]);
ProtocolLogger.AppendToLog(stringBuilder, "Uncb", this.storedData[ProtocolLoggerData.UNCBytes]);
ProtocolLogger.AppendToLog(stringBuilder, "Att", this.storedData[ProtocolLoggerData.Attachments]);
ProtocolLogger.AppendToLog(stringBuilder, "Attb", this.storedData[ProtocolLoggerData.AttachmentBytes]);
ProtocolLogger.AppendToLog(stringBuilder, "Pk", this.storedData[ProtocolLoggerData.PolicyKeyReceived]);
ProtocolLogger.AppendToLog(stringBuilder, "Pa", this.storedData[ProtocolLoggerData.PolicyAckStatus]);
ProtocolLogger.AppendToLog(stringBuilder, "Oof", this.storedData[ProtocolLoggerData.OOFVerb]);
ProtocolLogger.AppendToLog(stringBuilder, "UserInfo", this.storedData[ProtocolLoggerData.UserInformationVerb]);
ProtocolLogger.AppendToLog(stringBuilder, "DevModel", this.storedData[ProtocolLoggerData.DeviceInfoModel]);
ProtocolLogger.AppendToLog(stringBuilder, "DevIMEI", this.storedData[ProtocolLoggerData.DeviceInfoIMEI]);
ProtocolLogger.AppendToLog(stringBuilder, "DevName", this.storedData[ProtocolLoggerData.DeviceInfoFriendlyName]);
ProtocolLogger.AppendToLog(stringBuilder, "DevOS", this.storedData[ProtocolLoggerData.DeviceInfoOS]);
ProtocolLogger.AppendToLog(stringBuilder, "DevLang", this.storedData[ProtocolLoggerData.DeviceInfoOSLanguage]);
ProtocolLogger.AppendToLog(stringBuilder, "DevAgent", this.storedData[ProtocolLoggerData.DeviceInfoUserAgent]);
ProtocolLogger.AppendToLog(stringBuilder, "DevEnaSMS", this.storedData[ProtocolLoggerData.DeviceInfoEnableOutboundSMS]);
ProtocolLogger.AppendToLog(stringBuilder, "DevMoOp", this.storedData[ProtocolLoggerData.DeviceInfoMobileOperator]);
ProtocolLogger.AppendToLog(stringBuilder, "S", this.storedData[ProtocolLoggerData.StatusCode]);
ProtocolLogger.AppendToLog(stringBuilder, "Error", this.storedData[ProtocolLoggerData.Error]);
ProtocolLogger.AppendToLog(stringBuilder, "Msg", this.storedData[ProtocolLoggerData.Message]);
ProtocolLogger.AppendToLog(stringBuilder, "ADWR", this.storedData[ProtocolLoggerData.ADWriteReason]);
ProtocolLogger.AppendToLog(stringBuilder, "RR", this.storedData[ProtocolLoggerData.NumberOfRecipientsToResolve]);
ProtocolLogger.AppendToLog(stringBuilder, "Fb", this.storedData[ProtocolLoggerData.AvailabilityRequested]);
ProtocolLogger.AppendToLog(stringBuilder, "Ct", this.storedData[ProtocolLoggerData.CertificatesRequested]);
ProtocolLogger.AppendToLog(stringBuilder, "Pic", this.storedData[ProtocolLoggerData.PictureRequested]);
ProtocolLogger.AppendToLog(stringBuilder, "ItOefc", this.storedData[ProtocolLoggerData.IOEmptyFolderContents]);
ProtocolLogger.AppendToLog(stringBuilder, "ItOeefc", this.storedData[ProtocolLoggerData.IOEmptyFolderContentsErrors]);
ProtocolLogger.AppendToLog(stringBuilder, "ItOfd", this.storedData[ProtocolLoggerData.IOFetchDocs]);
ProtocolLogger.AppendToLog(stringBuilder, "ItOefd", this.storedData[ProtocolLoggerData.IOFetchDocErrors]);
ProtocolLogger.AppendToLog(stringBuilder, "ItOfi", this.storedData[ProtocolLoggerData.IOFetchItems]);
ProtocolLogger.AppendToLog(stringBuilder, "ItOefi", this.storedData[ProtocolLoggerData.IOFetchItemErrors]);
ProtocolLogger.AppendToLog(stringBuilder, "ItOfa", this.storedData[ProtocolLoggerData.IOFetchAtts]);
ProtocolLogger.AppendToLog(stringBuilder, "ItOfea", this.storedData[ProtocolLoggerData.IOFetchEntAtts]);
ProtocolLogger.AppendToLog(stringBuilder, "ItOefa", this.storedData[ProtocolLoggerData.IOFetchAttErrors]);
ProtocolLogger.AppendToLog(stringBuilder, "ItOm", this.storedData[ProtocolLoggerData.IOMoves]);
ProtocolLogger.AppendToLog(stringBuilder, "ItOem", this.storedData[ProtocolLoggerData.IOMoveErrors]);
ProtocolLogger.AppendToLog(stringBuilder, "MRi", this.storedData[ProtocolLoggerData.MRItems]);
ProtocolLogger.AppendToLog(stringBuilder, "MRe", this.storedData[ProtocolLoggerData.MRErrors]);
ProtocolLogger.AppendToLog(stringBuilder, "Mi", this.storedData[ProtocolLoggerData.MItems]);
ProtocolLogger.AppendToLog(stringBuilder, "MeI", this.storedData[ProtocolLoggerData.MIErrors]);
ProtocolLogger.AppendToLog(stringBuilder, "SrchP", this.storedData[ProtocolLoggerData.SearchProvider]);
ProtocolLogger.AppendToLog(stringBuilder, "SrchD", this.storedData[ProtocolLoggerData.SearchDeep]);
ProtocolLogger.AppendToLog(stringBuilder, "SrchL", this.storedData[ProtocolLoggerData.SearchQueryLength]);
ProtocolLogger.AppendToLog(stringBuilder, "SrchTime", this.storedData[ProtocolLoggerData.SearchQueryTime]);
ProtocolLogger.AppendToLog(stringBuilder, "Tpr", this.storedData[ProtocolLoggerData.TotalPhotoRequests]);
ProtocolLogger.AppendToLog(stringBuilder, "Spr", this.storedData[ProtocolLoggerData.SuccessfulPhotoRequests]);
ProtocolLogger.AppendToLog(stringBuilder, "Pfc", this.storedData[ProtocolLoggerData.PhotosFromCache]);
ProtocolLogger.AppendToLog(stringBuilder, "VCh", this.storedData[ProtocolLoggerData.VCertChains]);
ProtocolLogger.AppendToLog(stringBuilder, "VCe", this.storedData[ProtocolLoggerData.VCerts]);
ProtocolLogger.AppendToLog(stringBuilder, "VCRL", this.storedData[ProtocolLoggerData.VCertCRL]);
ProtocolLogger.AppendToLog(stringBuilder, "ClsName", this.storedData[ProtocolLoggerData.ClassName]);
ProtocolLogger.AppendToLog(stringBuilder, "Uuhp", this.storedData[ProtocolLoggerData.UpdateUserHasPartnerships]);
ProtocolLogger.AppendToLog(stringBuilder, "SkipSend", this.storedData[ProtocolLoggerData.SkipSend]);
ProtocolLogger.AppendToLog(stringBuilder, "MOLk", this.storedData[ProtocolLoggerData.MeetingOrganizerLookup]);
ProtocolLogger.AppendToLog(stringBuilder, "Em", this.storedData[ProtocolLoggerData.ExternallyManaged]);
ProtocolLogger.AppendToLog(stringBuilder, "GaC", this.storedData[ProtocolLoggerData.GraphApiCallData]);
ProtocolLogger.AppendToLog(stringBuilder, "As", this.storedData[ProtocolLoggerData.AccessStateAndReason]);
ProtocolLogger.AppendToLog(stringBuilder, "Ms", this.storedData[ProtocolLoggerData.MailSent]);
ProtocolLogger.AppendToLog(stringBuilder, "Ssu", this.storedData[ProtocolLoggerData.Ssu]);
ProtocolLogger.AppendToLog(stringBuilder, "Mbx", this.storedData[ProtocolLoggerData.MailboxServer]);
ProtocolLogger.AppendToLog(stringBuilder, "SNSSN", this.storedData[ProtocolLoggerData.SNSServiceServerName]);
ProtocolLogger.AppendToLog(stringBuilder, "Dc", this.storedData[ProtocolLoggerData.DomainController]);
ProtocolLogger.AppendToLog(stringBuilder, "Throttle", this.storedData[ProtocolLoggerData.ThrottledTime]);
ProtocolLogger.AppendToLog(stringBuilder, "SBkOffD", this.storedData[ProtocolLoggerData.SuggestedBackOffValue]);
ProtocolLogger.AppendToLog(stringBuilder, "BkOffRsn", this.storedData[ProtocolLoggerData.BackOffReason]);
ProtocolLogger.AppendToLog(stringBuilder, "DBL", this.storedData[ProtocolLoggerData.DeviceBehaviorLoaded]);
ProtocolLogger.AppendToLog(stringBuilder, "DBS", this.storedData[ProtocolLoggerData.DeviceBehaviorSaved]);
ProtocolLogger.AppendToLog(stringBuilder, "CmdHC", this.storedData[ProtocolLoggerData.CommandHashCode]);
ProtocolLogger.AppendToLog(stringBuilder, "SyncHC", this.storedData[ProtocolLoggerData.SyncHashCode]);
ProtocolLogger.AppendToLog(stringBuilder, "Ab", this.storedData[ProtocolLoggerData.AutoBlockEvent]);
ProtocolLogger.AppendToLog(stringBuilder, "Erd", this.storedData[ProtocolLoggerData.EmptyResponseDelayed]);
ProtocolLogger.AppendToLog(stringBuilder, "TmRcv", this.storedData[ProtocolLoggerData.TimeReceived]);
ProtocolLogger.AppendToLog(stringBuilder, "TmSt", this.storedData[ProtocolLoggerData.TimeStarted]);
ProtocolLogger.AppendToLog(stringBuilder, "TmDASt", this.storedData[ProtocolLoggerData.TimeDeviceAccessCheckStarted]);
ProtocolLogger.AppendToLog(stringBuilder, "TmPolSt", this.storedData[ProtocolLoggerData.TimePolicyCheckStarted]);
ProtocolLogger.AppendToLog(stringBuilder, "TmExSt", this.storedData[ProtocolLoggerData.TimeExecuteStarted]);
ProtocolLogger.AppendToLog(stringBuilder, "TmExFin", this.storedData[ProtocolLoggerData.TimeExecuteFinished]);
ProtocolLogger.AppendToLog(stringBuilder, "TmFin", this.storedData[ProtocolLoggerData.TimeFinished]);
ProtocolLogger.AppendToLog(stringBuilder, "TmCmpl", this.storedData[ProtocolLoggerData.TimeCompleted]);
ProtocolLogger.AppendToLog(stringBuilder, "TmHang", this.storedData[ProtocolLoggerData.TimeHang]);
ProtocolLogger.AppendToLog(stringBuilder, "TmCnt", this.storedData[ProtocolLoggerData.TimeContinued]);
ProtocolLogger.AppendToLog(stringBuilder, "NmDeferred", this.storedData[ProtocolLoggerData.NMDeferred]);
ProtocolLogger.AppendToLog(stringBuilder, "IcsHier", this.storedData[ProtocolLoggerData.QuickHierarchyChangeCheck]);
ProtocolLogger.AppendToLog(stringBuilder, "BlCARName", this.storedData[ProtocolLoggerData.BlockingClientAccessRuleName]);
ProtocolLogger.AppendToLog(stringBuilder, "LatCAR", this.storedData[ProtocolLoggerData.ClientAccessRulesLatency]);
ProtocolLogger.AppendToLog(stringBuilder, "ActivityContextData", this.storedData[ProtocolLoggerData.ActivityContextData]);
ProtocolLogger.AppendToLog(stringBuilder, "Budget", this.storedData[ProtocolLoggerData.Budget]);
return(stringBuilder.ToString());
}
internal DeviceInformationSetting(XmlNode request, XmlNode response, Command command, ProtocolLogger protocolLogger) : base(request, response, protocolLogger)
{
this.command = command;
this.mailboxSession = this.command.MailboxSession;
this.syncStateStorage = this.command.SyncStateStorage;
}
// Token: 0x06001867 RID: 6247 RVA: 0x0008F242 File Offset: 0x0008D442
public UserInformationSetting(XmlNode request, XmlNode response, IAirSyncUser user, MailboxSession mailboxSession, int version, ProtocolLogger protocolLogger) : base(request, response, protocolLogger)
{
this.user = user;
this.mailboxSession = mailboxSession;
this.version = version;
}
// Token: 0x06000CCE RID: 3278 RVA: 0x00044804 File Offset: 0x00042A04
public static MeetingOrganizerSyncState LoadFromMailbox(MailboxSession mailboxSession, SyncStateStorage syncStateStorage, ProtocolLogger protocolLogger)
{
if (mailboxSession == null)
{
throw new ArgumentNullException("mailboxSession");
}
if (syncStateStorage == null)
{
throw new ArgumentNullException("syncStateStorage");
}
bool flag = false;
MeetingOrganizerSyncState meetingOrganizerSyncState = null;
CustomSyncState customSyncState = null;
MeetingOrganizerSyncState result;
try
{
MeetingOrganizerSyncStateInfo meetingOrganizerSyncStateInfo = new MeetingOrganizerSyncStateInfo();
bool flag2 = false;
ExTraceGlobals.FaultInjectionTracer.TraceTest <bool>(3104189757U, ref flag2);
if (flag2)
{
throw new CorruptSyncStateException(meetingOrganizerSyncStateInfo.UniqueName, new LocalizedString("FaultInjection"));
}
bool isDirty = false;
customSyncState = syncStateStorage.GetCustomSyncState(meetingOrganizerSyncStateInfo, new PropertyDefinition[0]);
if (customSyncState == null)
{
customSyncState = syncStateStorage.CreateCustomSyncState(meetingOrganizerSyncStateInfo);
isDirty = true;
}
else if (customSyncState.BackendVersion != null && customSyncState.BackendVersion.Value != customSyncState.Version)
{
isDirty = true;
}
meetingOrganizerSyncState = new MeetingOrganizerSyncState(customSyncState);
meetingOrganizerSyncState.IsDirty = isDirty;
flag = true;
result = meetingOrganizerSyncState;
}
finally
{
if (!flag)
{
if (meetingOrganizerSyncState != null)
{
meetingOrganizerSyncState.Dispose();
}
else if (customSyncState != null)
{
customSyncState.Dispose();
}
}
}
return(result);
}
