// Token: 0x0600075A RID: 1882 RVA: 0x00028D88 File Offset: 0x00026F88
public static bool IsBlockedHostName(string hostName)
{
AirSyncDiagnostics.Assert(!string.IsNullOrEmpty(hostName));
if (DocumentLibraryUtility.RemoteDocumentsBlockedServers != null)
{
foreach (string b in DocumentLibraryUtility.RemoteDocumentsBlockedServers)
{
if (string.Equals(hostName, b, StringComparison.OrdinalIgnoreCase))
{
return(true);
}
}
}
if (DocumentLibraryUtility.RemoteDocumentsAllowedServers != null)
{
foreach (string b2 in DocumentLibraryUtility.RemoteDocumentsAllowedServers)
{
if (string.Equals(hostName, b2, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
}
}
return(DocumentLibraryUtility.RemoteDocumentsActionForUnknownServers == RemoteDocumentsActions.Block);
}
// Token: 0x06000757 RID: 1879 RVA: 0x00028C74 File Offset: 0x00026E74
public static bool IsInternalUri(Uri uri)
{
AirSyncDiagnostics.Assert(uri != null);
string host = uri.Host;
if (DocumentLibraryUtility.RemoteDocumentsInternalDomainSuffixList != null)
{
foreach (string value in DocumentLibraryUtility.RemoteDocumentsInternalDomainSuffixList)
{
if (host.EndsWith(value, StringComparison.OrdinalIgnoreCase))
{
return(true);
}
}
}
IPAddress ipaddress = new IPAddress(0L);
bool result;
try
{
result = (!IPAddress.TryParse(host, out ipaddress) && host.IndexOf('.') < 0);
}
catch (ArgumentException)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.AlgorithmTracer, null, "Invalid Uri Format in internal URI determination");
result = false;
}
return(result);
}
// Token: 0x060008E5 RID: 2277 RVA: 0x00035170 File Offset: 0x00033370
public void Delete(params ISyncItemId[] mailboxIds)
{
AirSyncDiagnostics.Assert(mailboxIds != null);
for (int i = 0; i < mailboxIds.Length; i++)
{
if (this.mailboxIdToSyncIdTable.ContainsKey(mailboxIds[i]))
{
string item = this.mailboxIdToSyncIdTable[mailboxIds[i]];
if (this.usingWriteBuffer)
{
if (!this.deletedItems.Contains(item) && !this.deletedItemsWriteBuffer.Contains(item))
{
this.deletedItemsWriteBuffer.Add(item);
}
}
else if (!this.deletedItems.Contains(item))
{
this.deletedItems.Add(item);
this.dirty = true;
}
}
else if (this.usingWriteBuffer && this.addedItemsWriteBufferReversed.ContainsKey(mailboxIds[i]))
{
this.addedItemsWriteBuffer.Remove(this.addedItemsWriteBufferReversed[mailboxIds[i]]);
this.addedItemsWriteBufferReversed.Remove(mailboxIds[i]);
}
else
{
AirSyncDiagnostics.Assert(false, "Id '{0}' is not found in the mapping", new object[]
{
mailboxIds[i]
});
}
}
}
// Token: 0x060008E6 RID: 2278 RVA: 0x00035274 File Offset: 0x00033474
public void Delete(params string[] syncIds)
{
AirSyncDiagnostics.Assert(syncIds != null);
for (int i = 0; i < syncIds.Length; i++)
{
if (this.syncIdToMailboxIdTable.ContainsKey(syncIds[i]))
{
if (this.usingWriteBuffer)
{
if (!this.deletedItems.Contains(syncIds[i]) && !this.deletedItemsWriteBuffer.Contains(syncIds[i]))
{
this.deletedItemsWriteBuffer.Add(syncIds[i]);
}
}
else if (!this.deletedItems.Contains(syncIds[i]))
{
this.deletedItems.Add(syncIds[i]);
this.dirty = true;
}
}
else if (this.usingWriteBuffer && this.addedItemsWriteBuffer.ContainsKey(syncIds[i]))
{
this.addedItemsWriteBufferReversed.Remove(this.addedItemsWriteBuffer[syncIds[i]]);
this.addedItemsWriteBuffer.Remove(syncIds[i]);
}
else
{
AirSyncDiagnostics.Assert(false, "Id '{0}' is not found in the mapping", new object[]
{
syncIds[i]
});
}
}
}
private void BuildPolicyResponse(XmlNode provisionNode)
{
AirSyncDiagnostics.Assert(this.responseProvisionStatus != ProvisionCommand.ProvisionStatusCode.NotPresent);
XmlNode xmlNode = this.owningCommand.XmlResponse.CreateElement("Status", "Provision:");
XmlNode xmlNode2 = xmlNode;
int num = (int)this.responseProvisionStatus;
xmlNode2.InnerText = num.ToString(CultureInfo.InvariantCulture);
provisionNode.AppendChild(xmlNode);
this.owningCommand.ProtocolLogger.SetValue(ProtocolLoggerData.StatusCode, (int)this.responseProvisionStatus);
if (this.responseProvisionStatus == ProvisionCommand.ProvisionStatusCode.Success && this.responsePolicyType != null)
{
XmlNode xmlNode3 = this.owningCommand.XmlResponse.CreateElement("Policies", "Provision:");
provisionNode.AppendChild(xmlNode3);
XmlNode xmlNode4 = this.owningCommand.XmlResponse.CreateElement("Policy", "Provision:");
xmlNode3.AppendChild(xmlNode4);
XmlNode xmlNode5 = this.owningCommand.XmlResponse.CreateElement("PolicyType", "Provision:");
xmlNode5.InnerText = this.responsePolicyType;
xmlNode4.AppendChild(xmlNode5);
AirSyncDiagnostics.Assert(this.responsePolicyStatus != ProvisionCommand.PolicyStatusCode.NotPresent);
XmlNode xmlNode6 = this.owningCommand.XmlResponse.CreateElement("Status", "Provision:");
XmlNode xmlNode7 = xmlNode6;
int num2 = (int)this.responsePolicyStatus;
xmlNode7.InnerText = num2.ToString(CultureInfo.InvariantCulture);
xmlNode4.AppendChild(xmlNode6);
if (this.responsePolicyKey != null)
{
XmlNode xmlNode8 = this.owningCommand.XmlResponse.CreateElement("PolicyKey", "Provision:");
xmlNode8.InnerText = this.responsePolicyKey.ToString();
xmlNode4.AppendChild(xmlNode8);
}
}
}
public void ParseOptions(XmlElement optionsNode)
{
if (optionsNode != null)
{
XmlNode xmlNode = optionsNode["Range", "Search:"];
if (xmlNode != null)
{
string[] array = xmlNode.InnerText.Split(new char[]
{
'-'
});
AirSyncDiagnostics.Assert(array.Length == 2);
this.minRange = int.Parse(array[0], CultureInfo.InvariantCulture);
this.maxRange = int.Parse(array[1], CultureInfo.InvariantCulture);
if (this.minRange > this.maxRange || (this.protocolVersion < 120 && this.minRange != 0))
{
throw new AirSyncPermanentException(StatusCode.Sync_ProtocolVersionMismatch, false)
{
ErrorStringForProtocolLogger = "MinMoreThanMaxinGalSearch"
};
}
this.rangeSpecified = true;
}
XmlNode pictureOptionsNode = optionsNode["Picture", "Search:"];
this.pictureOptions = PictureOptions.Parse(pictureOptionsNode, StatusCode.Sync_ProtocolVersionMismatch);
}
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.PictureRequested, (this.pictureOptions != null) ? 1 : 0);
}
private static void AppendToLogInternal(StringBuilder logString, string prefix, object objectToLog)
{
logString.Append(prefix);
if (objectToLog != null)
{
string text = objectToLog as string;
if (text != null)
{
logString.Append(':');
string text2 = HttpUtility.UrlEncode(text);
text2 = text2.Replace("_", "%5F");
logString.Append(text2);
}
else if (objectToLog is ExDateTime)
{
logString.Append(((ExDateTime)objectToLog).ToString("HH:mm:ss.FFFFFFF"));
}
else if (objectToLog is int || objectToLog is uint || objectToLog is long)
{
logString.Append(objectToLog.ToString());
}
else if (objectToLog is ProviderSyncType)
{
logString.Append(objectToLog.ToString().Replace(", ", "-"));
}
else
{
AirSyncDiagnostics.Assert(false, "Cannot log objects of this type", new object[0]);
}
}
logString.Append('_');
}
// Token: 0x06000759 RID: 1881 RVA: 0x00028D5C File Offset: 0x00026F5C
public static bool IsWssAccessEnabled(IAirSyncUser user)
{
AirSyncDiagnostics.Assert(user != null);
PolicyData policyData = ADNotificationManager.GetPolicyData(user);
return(policyData == null || policyData.WSSAccessEnabled);
}
public string Add(ISyncItemId mailboxItemId)
{
AirSyncDiagnostics.Assert(mailboxItemId != null);
if (mailboxItemId != null && mailboxItemId.NativeId != null)
{
StoreObjectId storeObjectId = mailboxItemId.NativeId as StoreObjectId;
if (storeObjectId != null && storeObjectId.ObjectType == StoreObjectType.CalendarItemOccurrence)
{
AirSyncDiagnostics.TraceDebug <ISyncItemId>(ExTraceGlobals.RequestsTracer, this, "CalendarItemOccurrence ItemId is being added to the ItemIdMapping! Id:{0}.", mailboxItemId);
}
}
string text;
if (base.OldIds.ContainsKey(mailboxItemId))
{
text = base.OldIds[mailboxItemId];
}
else
{
text = this.parentSyncId + ":" + base.UniqueCounter.ToString(CultureInfo.InvariantCulture);
}
AirSyncDiagnostics.Assert(text.Length <= 64);
base.Add(mailboxItemId, text);
return(text);
}
// Token: 0x0600073F RID: 1855 RVA: 0x00026AC4 File Offset: 0x00024CC4
public void ParseOptions(XmlElement optionsNode)
{
if (optionsNode != null)
{
int num = 0;
XmlNode xmlNode = optionsNode["Range", "Search:"];
if (xmlNode != null)
{
string[] array = xmlNode.InnerText.Split(new char[]
{
'-'
});
AirSyncDiagnostics.Assert(array.Length == 2);
this.minRange = int.Parse(array[0], CultureInfo.InvariantCulture);
this.maxRange = int.Parse(array[1], CultureInfo.InvariantCulture);
AirSyncDiagnostics.TraceDebug <int, int>(ExTraceGlobals.RequestsTracer, this, "Search command minRange is {0} and maxRange is {1}.", this.minRange, this.maxRange);
if (this.minRange > this.maxRange)
{
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "MinMoreThanMaxOnDocSearch");
throw new AirSyncPermanentException(StatusCode.Sync_ProtocolVersionMismatch, false);
}
this.rangeSpecified = true;
num++;
}
XmlNode xmlNode2 = optionsNode["UserName", "Search:"];
if (xmlNode2 != null)
{
AirSyncSecureStringXmlNode airSyncSecureStringXmlNode = optionsNode["Password", "Search:"] as AirSyncSecureStringXmlNode;
if (airSyncSecureStringXmlNode == null)
{
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "BadCredsOnDocSearch");
throw new AirSyncPermanentException(StatusCode.Sync_ProtocolVersionMismatch, false);
}
this.userName = xmlNode2.InnerText;
this.userPassword = airSyncSecureStringXmlNode.DetachSecureData();
AirSyncDiagnostics.TraceDebug <string>(ExTraceGlobals.RequestsTracer, this, "Search command userName is {0}.", this.userName);
num += 2;
}
if (num != optionsNode.ChildNodes.Count)
{
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "BadOptionsInDocSearch");
throw new AirSyncPermanentException(StatusCode.Sync_ProtocolVersionMismatch, false);
}
if (!string.Equals(this.user.Identity.AuthenticationType, "Basic", StringComparison.OrdinalIgnoreCase) && this.userPassword == null)
{
if (GlobalSettings.EnableCredentialRequest && this.user.Context.Request.Version >= 121)
{
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "NeedPromptForCredsToProxy");
throw new AirSyncPermanentException(StatusCode.Sync_InvalidWaitTime, false);
}
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "NeedCredsToProxy");
throw new AirSyncPermanentException(HttpStatusCode.Forbidden, StatusCode.AccessDenied, null, false);
}
}
}
private void BuildResponse(XmlNode provisionNode)
{
if (this.responseProvisionStatus == ProvisionCommand.ProvisionStatusCode.NotPresent)
{
AirSyncDiagnostics.Assert(this.responseProvisionStatus != ProvisionCommand.ProvisionStatusCode.NotPresent, "[ProvisionCommandPhaseOne.BuildResponse] ReponseProvisionStatus should NOT be NotPresent.", new object[0]);
}
XmlNode xmlNode = this.owningCommand.XmlResponse.CreateElement("Status", "Provision:");
XmlNode xmlNode2 = xmlNode;
int num = (int)this.responseProvisionStatus;
xmlNode2.InnerText = num.ToString(CultureInfo.InvariantCulture);
provisionNode.AppendChild(xmlNode);
this.owningCommand.ProtocolLogger.SetValue(ProtocolLoggerData.StatusCode, (int)this.responseProvisionStatus);
if (this.responseProvisionStatus == ProvisionCommand.ProvisionStatusCode.Success && this.responsePolicyType != null)
{
XmlNode xmlNode3 = this.owningCommand.XmlResponse.CreateElement("Policies", "Provision:");
provisionNode.AppendChild(xmlNode3);
XmlNode xmlNode4 = this.owningCommand.XmlResponse.CreateElement("Policy", "Provision:");
xmlNode3.AppendChild(xmlNode4);
XmlNode xmlNode5 = this.owningCommand.XmlResponse.CreateElement("PolicyType", "Provision:");
xmlNode5.InnerText = this.responsePolicyType;
xmlNode4.AppendChild(xmlNode5);
AirSyncDiagnostics.Assert(this.responsePolicyStatus != ProvisionCommand.PolicyStatusCode.NotPresent);
XmlNode xmlNode6 = this.owningCommand.XmlResponse.CreateElement("Status", "Provision:");
XmlNode xmlNode7 = xmlNode6;
int num2 = (int)this.responsePolicyStatus;
xmlNode7.InnerText = num2.ToString(CultureInfo.InvariantCulture);
xmlNode4.AppendChild(xmlNode6);
if (this.responsePolicyKey != null)
{
XmlNode xmlNode8 = this.owningCommand.XmlResponse.CreateElement("PolicyKey", "Provision:");
xmlNode8.InnerText = this.responsePolicyKey.ToString();
xmlNode4.AppendChild(xmlNode8);
}
if (this.responsePolicyData != null)
{
XmlNode xmlNode9 = this.owningCommand.XmlResponse.CreateElement("Data", "Provision:");
xmlNode4.AppendChild(xmlNode9);
if (string.Equals(this.responsePolicyType, "MS-WAP-Provisioning-XML", StringComparison.OrdinalIgnoreCase))
{
xmlNode9.InnerText = this.responsePolicyData;
}
else if (string.Equals(this.responsePolicyType, "MS-EAS-Provisioning-WBXML", StringComparison.OrdinalIgnoreCase))
{
xmlNode9.InnerXml = this.responsePolicyData;
}
else
{
AirSyncDiagnostics.Assert(false, "Unknown policy type", new object[0]);
}
}
}
base.GenerateRemoteWipeIfNeeded(provisionNode);
}
// Token: 0x06000756 RID: 1878 RVA: 0x00028C34 File Offset: 0x00026E34
public static bool IsTrustedProtocol(string protocol)
{
AirSyncDiagnostics.Assert(!string.IsNullOrEmpty(protocol));
for (int i = 0; i < DocumentLibraryUtility.trustedProtocols.Length; i++)
{
if (string.Equals(protocol, DocumentLibraryUtility.trustedProtocols[i], StringComparison.OrdinalIgnoreCase))
{
return(true);
}
}
return(false);
}
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());
}
public string Add(ISyncItemId mailboxFolderId)
{
AirSyncDiagnostics.Assert(mailboxFolderId != null);
string text;
if (base.OldIds.ContainsKey(mailboxFolderId))
{
text = base.OldIds[mailboxFolderId];
}
else
{
text = base.UniqueCounter.ToString(CultureInfo.InvariantCulture);
}
base.Add(mailboxFolderId, text);
return(text);
}
// Token: 0x060008EC RID: 2284 RVA: 0x00035640 File Offset: 0x00033840
protected void Add(ISyncItemId mailboxId, string syncId)
{
AirSyncDiagnostics.Assert(mailboxId != null);
AirSyncDiagnostics.Assert(syncId != null);
if (this.syncIdToMailboxIdTable.ContainsKey(syncId))
{
ISyncItemId syncItemId = this.syncIdToMailboxIdTable[syncId];
if (syncItemId.Equals(mailboxId))
{
return;
}
throw new InvalidOperationException("SyncId has already been mapped to a different MailboxId");
}
else if (this.usingWriteBuffer && this.addedItemsWriteBuffer.ContainsKey(syncId))
{
ISyncItemId syncItemId2 = this.addedItemsWriteBuffer[syncId];
if (syncItemId2.Equals(mailboxId))
{
return;
}
throw new InvalidOperationException("SyncId has already been mapped to a different MailboxId");
}
else
{
if (this.mailboxIdToSyncIdTable.ContainsKey(mailboxId) || (this.usingWriteBuffer && this.addedItemsWriteBufferReversed.ContainsKey(mailboxId)))
{
throw new InvalidOperationException("MailboxId has already been mapped to a different SyncId");
}
if (this.usingWriteBuffer)
{
this.addedItemsWriteBuffer[syncId] = mailboxId;
this.addedItemsWriteBufferReversed[mailboxId] = syncId;
this.uniqueCounter += 1L;
return;
}
this.syncIdToMailboxIdTable.Add(syncId, mailboxId);
this.mailboxIdToSyncIdTable.Add(mailboxId, syncId);
this.addedItems.Add(syncId);
this.uniqueCounter += 1L;
this.dirty = true;
return;
}
}
// Token: 0x06000D08 RID: 3336 RVA: 0x00046FC0 File Offset: 0x000451C0
private void AppendItemXmlNode(string srcMsgId, string status, string dstMsgId)
{
AirSyncDiagnostics.Assert(base.XmlResponse != null);
XmlElement xmlElement = base.XmlResponse.CreateElement("Response", "Move:");
this.moveitemsNode.AppendChild(xmlElement);
XmlElement xmlElement2 = base.XmlResponse.CreateElement("SrcMsgId", "Move:");
xmlElement2.InnerText = srcMsgId;
xmlElement.AppendChild(xmlElement2);
XmlElement xmlElement3 = base.XmlResponse.CreateElement("Status", "Move:");
xmlElement3.InnerText = status;
xmlElement.AppendChild(xmlElement3);
if (dstMsgId != null)
{
XmlElement xmlElement4 = base.XmlResponse.CreateElement("DstMsgId", "Move:");
xmlElement4.InnerText = dstMsgId;
xmlElement.AppendChild(xmlElement4);
}
}
public int?[] UpdateChangeTrackingInformation(XmlNode xmlItemRoot, int?[] oldChangeTrackingInformation)
{
this.seenNodes = new XmlNode[this.changeTrackingNodes.Values.Count];
this.newChangeTrackingInformation = new int?[this.changeTrackingNodes.Values.Count];
this.newChangeTrackingInformation[0] = this.ComputeHash(xmlItemRoot, true);
if (this.fillInMissingHashes && oldChangeTrackingInformation != null)
{
AirSyncDiagnostics.Assert(this.newChangeTrackingInformation.Length >= oldChangeTrackingInformation.Length, "newChangeTrackingInformation.Length = {0}, oldChangeTrackingInformation.Length = {1}", new object[]
{
this.newChangeTrackingInformation.Length,
oldChangeTrackingInformation.Length
});
int num = 0;
while (num < this.changeTrackingNodes.Values.Count && num < oldChangeTrackingInformation.Length)
{
if (this.newChangeTrackingInformation[num] == null)
{
this.newChangeTrackingInformation[num] = oldChangeTrackingInformation[num];
}
num++;
}
}
return(this.newChangeTrackingInformation);
}
public void BuildResponse(XmlElement responseNode)
{
try
{
int num = 0;
this.numberResponses = 0;
XmlNode xmlNode = responseNode.OwnerDocument.CreateElement("Status", "Search:");
responseNode.AppendChild(xmlNode);
xmlNode.InnerText = 1.ToString(CultureInfo.InvariantCulture);
int num2 = this.minRange;
while (this.addressBookObjects != null && num2 <= this.maxRange && num2 < this.addressBookObjects.Count)
{
ABObject abobject = this.addressBookObjects[num2];
if (abobject != null)
{
ABContact abcontact = abobject as ABContact;
XmlNode xmlNode2 = responseNode.OwnerDocument.CreateElement("Result", "Search:");
XmlNode xmlNode3 = responseNode.OwnerDocument.CreateElement("Properties", "Search:");
xmlNode2.AppendChild(xmlNode3);
for (int i = 0; i < GalSearchProvider.schema.Length; i++)
{
string abproperty;
if (abcontact == null)
{
abproperty = GalSearchProvider.GetABProperty(abobject, GalSearchProvider.schema[i]);
}
else
{
abproperty = GalSearchProvider.GetABProperty(abcontact, GalSearchProvider.schema[i]);
}
if (!string.IsNullOrEmpty(abproperty))
{
XmlNode xmlNode4 = responseNode.OwnerDocument.CreateElement(GalSearchProvider.schema[i], "Gal:");
xmlNode4.InnerText = abproperty;
xmlNode3.AppendChild(xmlNode4);
}
}
if (this.pictureOptions != null && abcontact != null)
{
StatusCode statusCode = StatusCode.Success;
byte[] array = null;
if (this.user.Features.IsEnabled(EasFeature.HDPhotos) && this.user.Context.Request.Version >= 160)
{
array = this.photoRetriever.EndGetThumbnailPhotoFromMailbox(abcontact.EmailAddress, GlobalSettings.MaxRequestExecutionTime - ExDateTime.Now.Subtract(Command.CurrentCommand.Context.RequestTime), this.pictureOptions.PhotoSize);
AirSyncDiagnostics.TraceDebug <bool, int>(ExTraceGlobals.RequestsTracer, this, "GalSearch Requesting user's HD picture. WasRetrived:{0}, size:{1}", array != null, (array == null) ? 0 : array.Length);
}
if (statusCode != StatusCode.Success || array == null)
{
AirSyncDiagnostics.TraceDebug <bool, int, StatusCode>(ExTraceGlobals.RequestsTracer, this, "User's HD photo is either null or was not requested, Using contact's picture from AD. :FeatureEnabled:{0}, RequestVersion:{1}, statusCode:{2}", this.user.Features.IsEnabled(EasFeature.HDPhotos), this.user.Context.Request.Version, statusCode);
array = abcontact.Picture;
}
bool flag;
XmlNode newChild = this.pictureOptions.CreatePictureNode(responseNode.OwnerDocument, "Gal:", array, num >= this.pictureOptions.MaxPictures, out flag);
xmlNode3.AppendChild(newChild);
if (flag)
{
num++;
}
}
responseNode.AppendChild(xmlNode2);
this.numberResponses++;
}
num2++;
}
if (this.numberResponses == 0)
{
XmlNode newChild2 = responseNode.OwnerDocument.CreateElement("Result", "Search:");
responseNode.AppendChild(newChild2);
}
else if (this.rangeSpecified)
{
XmlNode xmlNode5 = responseNode.OwnerDocument.CreateElement("Range", "Search:");
XmlNode xmlNode6 = responseNode.OwnerDocument.CreateElement("Total", "Search:");
xmlNode5.InnerText = this.minRange.ToString(CultureInfo.InvariantCulture) + "-" + (this.minRange + this.numberResponses - 1).ToString(CultureInfo.InvariantCulture);
responseNode.AppendChild(xmlNode5);
AirSyncDiagnostics.Assert(this.addressBookObjects.Count <= GlobalSettings.MaxGALSearchResults);
xmlNode6.InnerText = this.addressBookObjects.Count.ToString(CultureInfo.InvariantCulture);
responseNode.AppendChild(xmlNode6);
}
}
finally
{
if (this.photoRetriever != null)
{
this.photoRetriever.Dispose();
this.photoRetriever = null;
}
}
}
// Token: 0x0600074D RID: 1869 RVA: 0x00027EFC File Offset: 0x000260FC
public void Execute()
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "DocumentLibrary Fetch command received. Processing request...");
Uri uri = null;
try
{
uri = new Uri(this.linkId);
}
catch (UriFormatException innerException)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, string.Format(CultureInfo.InvariantCulture, "ItemOperationsFetchProvider: Bad document Uri {0} was specified!", new object[]
{
this.linkId
}));
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "BadLinkInDocFetch");
throw new AirSyncPermanentException(StatusCode.Sync_ProtocolError, innerException, false);
}
AirSyncDiagnostics.TraceDebug <string>(ExTraceGlobals.RequestsTracer, this, "Processing Fetch command with Uri {0}.", uri.AbsoluteUri);
if (!DocumentLibraryUtility.IsTrustedProtocol(uri.Scheme))
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, string.Format(CultureInfo.InvariantCulture, "ItemOperationsFetchProvider: untrusted protocol: {0}!", new object[]
{
uri.Scheme
}));
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "BadProtocolInDocFetch");
throw new AirSyncPermanentException(StatusCode.Sync_Retry, false);
}
if (!DocumentLibraryUtility.IsInternalUri(uri))
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, string.Format(CultureInfo.InvariantCulture, "ItemOperationsFetchProvider: Uri must be internal: {0}!", new object[]
{
uri.Host
}));
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ExternalProtocolInDocFetch");
throw new AirSyncPermanentException(StatusCode.Sync_Retry, false);
}
AuthenticationContext authenticationContext = new AuthenticationContext();
try
{
IPrincipal principal;
if (this.userPassword == null)
{
principal = this.user.WindowsPrincipal;
if (principal == null)
{
if (GlobalSettings.EnableCredentialRequest && this.user.Context.Request.Version >= 121)
{
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "NeedPromptForCredsToProxy2");
throw new AirSyncPermanentException(StatusCode.ItemOperations_CredentialsRequired, false);
}
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "NeedCredsToProxy2");
throw new AirSyncPermanentException(HttpStatusCode.Forbidden, StatusCode.AccessDenied, null, false);
}
}
else
{
SecurityStatus securityStatus = authenticationContext.LogonUser(this.userName, this.userPassword);
this.userPassword.Dispose();
this.userPassword = null;
if (securityStatus != SecurityStatus.OK)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, string.Format(CultureInfo.InvariantCulture, "ItemOperationsFetchProvider: Authentication failed with status {0}.", new object[]
{
securityStatus
}));
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, string.Format(CultureInfo.InvariantCulture, "AuthenticationErrorStatus{0}", new object[]
{
securityStatus
}));
throw new AirSyncPermanentException(HttpStatusCode.OK, StatusCode.Sync_ServerError, null, false);
}
principal = new WindowsPrincipal(authenticationContext.Identity);
}
ClassifyResult classifyResult = LinkClassifier.ClassifyLinks(principal, new Uri[]
{
uri
})[0];
if (classifyResult.Error != ClassificationError.None)
{
AirSyncDiagnostics.TraceDebug <string, ClassificationError>(ExTraceGlobals.RequestsTracer, this, "The LinkClassifier failed to classify the link {0}, returned {1}", this.linkId, classifyResult.Error);
switch (classifyResult.Error)
{
case ClassificationError.ConnectionFailed:
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "LinkClassConnFailedInDocFetch");
throw new AirSyncPermanentException(HttpStatusCode.OK, StatusCode.Sync_Conflict, null, false);
case ClassificationError.AccessDenied:
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "LinkClassDeniedInDocFetch");
throw new AirSyncPermanentException(HttpStatusCode.OK, StatusCode.Sync_ServerError, null, false);
case ClassificationError.ObjectNotFound:
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "LinkClassNotFoundInDocFetch");
throw new AirSyncPermanentException(HttpStatusCode.OK, StatusCode.Sync_ClientServerConversion, null, false);
case ClassificationError.UriTypeNotSupported:
case ClassificationError.InvalidUri:
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "LinkClassBadUriInDocFetch");
throw new AirSyncPermanentException(HttpStatusCode.OK, StatusCode.Sync_ProtocolError, null, false);
}
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "LinkClassFailureInDocFetch");
throw new AirSyncPermanentException(StatusCode.Sync_InvalidSyncKey, false);
}
IDocument document = null;
UncSession uncSession = null;
SharepointSession sharepointSession = null;
if ((classifyResult.UriFlags & UriFlags.UncDocument) == UriFlags.UncDocument)
{
if (!DocumentLibraryUtility.IsUncAccessEnabled(this.user))
{
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "AccessDeniedInDocFetch");
throw new AirSyncPermanentException(StatusCode.Sync_Retry, false);
}
if (DocumentLibraryUtility.IsBlockedHostName(uri.Host))
{
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "HostBlockedInDocFetch");
throw new AirSyncPermanentException(StatusCode.Sync_Retry, false);
}
uncSession = UncSession.Open(classifyResult.ObjectId, principal);
}
else
{
if ((classifyResult.UriFlags & UriFlags.SharepointDocument) != UriFlags.SharepointDocument)
{
AirSyncDiagnostics.TraceDebug <string, UriFlags>(ExTraceGlobals.RequestsTracer, this, "The Uri {0} of type {1} is not supported for Fetch", this.linkId, classifyResult.UriFlags);
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "BadLinkInDocFetch2");
throw new AirSyncPermanentException(StatusCode.Sync_ProtocolError, false);
}
if (!DocumentLibraryUtility.IsWssAccessEnabled(this.user))
{
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "WssDeniedInDocFetch");
throw new AirSyncPermanentException(StatusCode.Sync_Retry, false);
}
if (DocumentLibraryUtility.IsBlockedHostName(uri.Host))
{
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "HostBlockedInDocFetch2");
throw new AirSyncPermanentException(StatusCode.Sync_Retry, false);
}
this.user.Context.ProtocolLogger.IncrementValue(ProtocolLoggerData.SharePointDocs);
sharepointSession = SharepointSession.Open(classifyResult.ObjectId, principal);
}
try
{
if (uncSession != null)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "Reading UNC document...");
document = UncDocument.Read(uncSession, classifyResult.ObjectId);
}
else
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "Reading Sharepoint document...");
AirSyncDiagnostics.Assert(sharepointSession != null);
document = SharepointDocument.Read(sharepointSession, classifyResult.ObjectId);
}
}
catch (ObjectNotFoundException innerException2)
{
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "NotFoundInDocFetch");
throw new AirSyncPermanentException(StatusCode.Sync_ClientServerConversion, innerException2, false);
}
catch (AccessDeniedException innerException3)
{
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "AccessDeniedInDocFetch2");
throw new AirSyncPermanentException(StatusCode.Sync_ServerError, innerException3, false);
}
this.documentSize = (int)document.Size;
if (this.documentSize == 0)
{
AirSyncDiagnostics.TraceDebug <string>(ExTraceGlobals.RequestsTracer, this, "The file {0} was found to be empty!", this.linkId);
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "EmptyDocInDocFetch");
throw new AirSyncPermanentException(HttpStatusCode.OK, StatusCode.Sync_NotificationGUID, null, false);
}
object obj = document.TryGetProperty(DocumentLibraryItemSchema.LastModifiedDate);
if (obj is PropertyError)
{
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "GeneralErrorInDocFetch");
throw new AirSyncPermanentException(StatusCode.Sync_InvalidSyncKey, false);
}
ExDateTime exDateTime;
if (obj is DateTime)
{
exDateTime = new ExDateTime(ExTimeZone.UtcTimeZone, (DateTime)obj);
}
else
{
exDateTime = (ExDateTime)obj;
}
this.version = exDateTime.ToString("yyyy-MM-dd\\THH:mm:ss.fff\\Z", CultureInfo.InvariantCulture);
if (this.rangeSpecified && this.minRange >= this.documentSize)
{
AirSyncDiagnostics.TraceDebug <int, int>(ExTraceGlobals.RequestsTracer, this, "The minimum range specified {0} is greater than the document size {1}", this.minRange, this.documentSize);
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "BadMinSizeInDocFetch");
throw new AirSyncPermanentException(HttpStatusCode.OK, StatusCode.Sync_ObjectNotFound, null, false);
}
using (Stream document2 = document.GetDocument())
{
int num;
if (this.rangeSpecified)
{
num = this.maxRange - this.minRange + 1;
}
else
{
num = this.documentSize;
}
if (uncSession != null)
{
this.user.Context.ProtocolLogger.IncrementValue(ProtocolLoggerData.UNCFiles);
this.user.Context.ProtocolLogger.IncrementValueBy(ProtocolLoggerData.UNCBytes, num);
}
if (sharepointSession != null)
{
this.user.Context.ProtocolLogger.IncrementValue(ProtocolLoggerData.SharePointDocs);
this.user.Context.ProtocolLogger.IncrementValueBy(ProtocolLoggerData.SharePointBytes, num);
}
this.outStream = new MemoryStream(num);
if (num > GlobalSettings.MaxDocumentDataSize)
{
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "DocTooBigInDocFetch");
throw new AirSyncPermanentException(StatusCode.Sync_NotificationsNotProvisioned, false);
}
try
{
StreamHelper.CopyStream(document2, this.outStream, this.minRange, num);
}
catch (IOException innerException4)
{
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "IOErrorInDocFetch");
throw new AirSyncPermanentException(StatusCode.Sync_FolderHierarchyRequired, innerException4, false);
}
}
}
catch (UnknownErrorException innerException5)
{
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "IOErrorInDocFetch2");
throw new AirSyncPermanentException(StatusCode.Sync_FolderHierarchyRequired, innerException5, false);
}
catch (DocumentModifiedException innerException6)
{
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "IOErrorInDocFetch3");
throw new AirSyncPermanentException(StatusCode.Sync_FolderHierarchyRequired, innerException6, false);
}
catch (DocumentStreamAccessDeniedException innerException7)
{
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "AccessDeniedInDocFetch3");
throw new AirSyncPermanentException(StatusCode.Sync_ServerError, innerException7, false);
}
catch (ObjectMovedOrDeletedException innerException8)
{
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "NotFoundInDocFetch2");
throw new AirSyncPermanentException(StatusCode.Sync_ClientServerConversion, innerException8, false);
}
catch (DocumentLibraryException innerException9)
{
this.user.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "GeneralErrorInDocFetch2");
throw new AirSyncPermanentException(StatusCode.Sync_InvalidSyncKey, innerException9, false);
}
finally
{
if (authenticationContext != null)
{
authenticationContext.Dispose();
authenticationContext = null;
}
}
}
// Token: 0x06000C29 RID: 3113 RVA: 0x0003F778 File Offset: 0x0003D978
internal override Command.ExecutionState ExecuteCommand()
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "ItemOperationsCommand received. Processing the command...");
try
{
XmlDocument xmlDocument = null;
XmlNode xmlRequest = base.XmlRequest;
if (xmlRequest.ChildNodes.Count > GlobalSettings.MaxRetrievedItems)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "CapReached");
string message = string.Format("ItemOperations cap is reached, Cap = {0}, ChildNode = {1}", GlobalSettings.MaxRetrievedItems, xmlRequest.ChildNodes.Count);
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, message);
xmlDocument = this.BuildXmlResponse(11.ToString(CultureInfo.InvariantCulture));
base.ProtocolLogger.SetValue(ProtocolLoggerData.StatusCode, 11);
}
else
{
xmlDocument = this.BuildXmlResponse(1.ToString(CultureInfo.InvariantCulture));
base.ProtocolLogger.SetValue(ProtocolLoggerData.StatusCode, 1);
int i = 0;
while (i < xmlRequest.ChildNodes.Count)
{
XmlNode xmlNode = xmlRequest.ChildNodes[i];
string localName;
if ((localName = xmlNode.LocalName) == null)
{
goto IL_278;
}
if (localName == "EmptyFolderContents")
{
this.currentProvider = this.EmptyFolderContentsProvider;
base.ProtocolLogger.IncrementValue(ProtocolLoggerData.IOEmptyFolderContents);
goto IL_27E;
}
if (!(localName == "Fetch"))
{
if (!(localName == "Move"))
{
goto IL_278;
}
this.currentProvider = this.MoveProvider;
base.ProtocolLogger.IncrementValue(ProtocolLoggerData.IOMoves);
goto IL_27E;
}
else
{
XmlNode xmlNode2 = xmlNode["Store", "ItemOperations:"];
string a;
if ((a = xmlNode2.InnerText.ToLower(CultureInfo.InvariantCulture)) != null)
{
if (a == "documentlibrary")
{
this.currentProvider = this.DocumentFetchProvider;
base.ProtocolLogger.IncrementValue(ProtocolLoggerData.IOFetchDocs);
goto IL_27E;
}
if (a == "mailbox")
{
XmlNode xmlNode3 = xmlNode["FileReference", "AirSyncBase:"];
if (xmlNode3 == null)
{
this.currentProvider = this.ItemFetchProvider;
base.ProtocolLogger.IncrementValue(ProtocolLoggerData.IOFetchItems);
goto IL_27E;
}
if (base.Version >= 160 && xmlNode3.InnerText != null && xmlNode3.InnerText.IndexOf("%3a") > 16)
{
this.currentProvider = this.EntityAttachmentFetchProvider;
base.ProtocolLogger.IncrementValue(ProtocolLoggerData.IOFetchEntAtts);
goto IL_27E;
}
this.currentProvider = this.AttachmentFetchProvider;
base.ProtocolLogger.IncrementValue(ProtocolLoggerData.IOFetchAtts);
goto IL_27E;
}
}
this.AppendFetchErrorXml(xmlDocument, 9.ToString(CultureInfo.InvariantCulture));
base.ProtocolLogger.SetValue(ProtocolLoggerData.StatusCode, 9);
}
IL_3C0:
i++;
continue;
Block_15:
try
{
IL_27E:
this.currentProvider.ParseRequest(xmlNode);
this.currentProvider.Execute();
if (base.Request.AcceptMultiPartResponse && this.currentProvider is IMultipartResponse)
{
IMultipartResponse multipartResponse = this.currentProvider as IMultipartResponse;
multipartResponse.BuildResponse(this.responseNode, this.multipartStreams.Count + 1);
Stream responseStream = multipartResponse.GetResponseStream();
if (responseStream != null)
{
this.multipartStreams.Add(responseStream);
}
}
else
{
this.currentProvider.BuildResponse(this.responseNode);
}
this.currentProvider.Reset();
}
catch (AirSyncPermanentException ex)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.StatusCode, (int)ex.AirSyncStatusCode);
if (ex.HttpStatusCode != HttpStatusCode.OK)
{
throw;
}
base.ProtocolLogger.SetValueIfNotSet(ProtocolLoggerData.Error, ex.ErrorStringForProtocolLogger);
AirSyncUtility.ExceptionToStringHelper arg = new AirSyncUtility.ExceptionToStringHelper(ex);
AirSyncDiagnostics.TraceError <AirSyncUtility.ExceptionToStringHelper>(ExTraceGlobals.ProtocolTracer, this, "AirSyncPermanentException was thrown. Location Execute.\r\n{0}", arg);
if (base.MailboxLogger != null)
{
base.MailboxLogger.SetData(MailboxLogDataName.ItemOperationsCommand_Execute_Fetch_Exception, ex);
}
this.currentProvider.BuildErrorResponse(ex.AirSyncStatusCodeInInt.ToString(CultureInfo.InvariantCulture), this.responseNode, base.ProtocolLogger);
this.currentProvider.Reset();
base.PartialFailure = true;
}
goto IL_3C0;
IL_278:
AirSyncDiagnostics.Assert(false);
goto Block_15;
}
}
if (base.Request.AcceptMultiPartResponse)
{
this.BuildMultiPartResponse(xmlDocument);
}
else
{
base.XmlResponse = xmlDocument;
}
}
finally
{
this.DisposeResources();
}
return(Command.ExecutionState.Complete);
}
private void BackEndGetResponse(IAsyncResult asynchronousResult)
{
lock (this)
{
if (this.requestWasTimedOut)
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "ProxyHandler.BackEndGetResponse() Request was timed out while waiting for lock!");
string text = this.remoteUri.Host.ToString();
AirSyncDiagnostics.LogPeriodicEvent(AirSyncEventLogConstants.Tuple_ProxyResultTimedOut, text, new string[]
{
text
});
return;
}
}
try
{
AirSyncDiagnostics.TraceDebug <Uri, string>(ExTraceGlobals.RequestsTracer, this, "ProxyHandler.BackEndGetResponse called for serverName: {0}, user {1}", this.remoteUri, this.userName);
this.UnregisterTimeoutWaitHandle();
try
{
this.httpWebResponse = (HttpWebResponse)this.backEndWebRequest.EndGetResponse(asynchronousResult);
}
catch (WebException ex)
{
if (ex.Status == WebExceptionStatus.ProtocolError)
{
HttpWebResponse httpWebResponse = ex.Response as HttpWebResponse;
if (httpWebResponse == null)
{
this.HandleException(ex);
return;
}
if (httpWebResponse.StatusCode == (HttpStatusCode)441)
{
httpWebResponse.Close();
if (!this.proxyInfo.AttemptProxyLogin)
{
AirSyncDiagnostics.TraceDebug <string>(ExTraceGlobals.RequestsTracer, this, "BackEndGetResponse(): authentication failure for {0}.", this.userName);
this.TryUnregisterTimeoutWaitHandle();
this.frontEndHttpContext.Response.StatusCode = 403;
this.frontEndResult.InvokeCallback();
return;
}
AirSyncDiagnostics.Assert(!this.proxyInfo.RequiresImpersonation && this.proxyInfo.AdditionalHeaders != null);
AirSyncDiagnostics.TraceDebug <string>(ExTraceGlobals.RequestsTracer, this, "BackEndGetResponse(): proxy login required for {0}.", this.userName);
if (this.proxyLoginAttempts > 0)
{
AirSyncDiagnostics.TraceFunction(ExTraceGlobals.RequestsTracer, this, "BackEndGetResponse(): too many login attempts.");
this.protocolLogger.SetValue(ProtocolLoggerData.Error, "TooManyProxyLoginAttempts");
this.TryUnregisterTimeoutWaitHandle();
this.frontEndHttpContext.Response.StatusCode = 403;
this.frontEndResult.InvokeCallback();
return;
}
this.proxyLoginAttempts++;
this.IssueProxyLoginRequest();
return;
}
else
{
if (httpWebResponse.Headers != null)
{
WebHeaderCollection headers = httpWebResponse.Headers;
string text2 = headers["WWW-Authenticate"];
if (text2 != null && text2.IndexOf("Negotiate ") == -1)
{
if (this.HasBeenProxiedByMServ)
{
this.protocolLogger.SetValue(ProtocolLoggerData.Error, "Datacenter Config issue upon MServ proxy");
}
else
{
this.protocolLogger.SetValue(ProtocolLoggerData.Error, "NTLM not on the destination CAS");
string text3 = this.proxyInfo.RemoteUri.Host.ToString();
AirSyncDiagnostics.LogPeriodicEvent(AirSyncEventLogConstants.Tuple_SecondCasFailureNTLM, text3, new string[]
{
text3
});
}
}
}
this.httpWebResponse = httpWebResponse;
}
}
else
{
if (ex.Status == WebExceptionStatus.TrustFailure)
{
AirSyncDiagnostics.TraceDebug <string>(ExTraceGlobals.RequestsTracer, this, "SSL Certification failed for {0}.", this.proxyInfo.RemoteUri.Host);
this.protocolLogger.SetValue(ProtocolLoggerData.Error, "SSL Certification Failed.");
string text4 = this.proxyInfo.RemoteUri.Host.ToString();
AirSyncDiagnostics.LogPeriodicEvent(AirSyncEventLogConstants.Tuple_SecondCasFailureSSL, text4, new string[]
{
text4
});
this.HandleException(ex);
return;
}
this.HandleException(ex);
return;
}
}
if (GlobalSettings.ProxyHeaders != null && GlobalSettings.ProxyHeaders.Length > 0)
{
this.frontEndHttpContext.Response.ContentType = string.Empty;
for (int i = 0; i < this.httpWebResponse.Headers.Count; i++)
{
string text5 = this.httpWebResponse.Headers.Keys[i];
for (int j = 0; j < GlobalSettings.ProxyHeaders.Length; j++)
{
if (string.Equals(text5, GlobalSettings.ProxyHeaders[j], StringComparison.OrdinalIgnoreCase))
{
this.frontEndHttpContext.Response.AppendHeader(text5, this.httpWebResponse.Headers[text5]);
}
}
}
}
this.backEndResponseStream = this.httpWebResponse.GetResponseStream();
this.frontEndHttpContext.Response.StatusCode = (int)this.httpWebResponse.StatusCode;
this.frontEndHttpContext.Response.StatusDescription = this.httpWebResponse.StatusDescription;
this.pendingAsyncOperation = ProxyHandler.PendingOperationState.BackEndReadContent;
IAsyncResult asyncResult = this.backEndResponseStream.BeginRead(this.asyncBuffer, 0, this.asyncBuffer.Length, new AsyncCallback(this.BackEndReadContent), null);
if (!asyncResult.CompletedSynchronously)
{
this.RegisterTimeoutWaitHandle(asyncResult, (int)GlobalSettings.ProxyHandlerShortTimeout.TotalMilliseconds);
}
}
catch (Exception ex2)
{
AirSyncUtility.ExceptionToStringHelper arg = new AirSyncUtility.ExceptionToStringHelper(ex2);
AirSyncDiagnostics.TraceError <AirSyncUtility.ExceptionToStringHelper>(ExTraceGlobals.RequestsTracer, this, "ProxyHandler.BackEndGetResponse caught an exception\r\n{0}", arg);
if (this.backEndWebRequest != null)
{
this.backEndWebRequest.Abort();
this.backEndWebRequest = null;
}
this.HandleException(ex2);
}
}
public new void Add(ISyncItemId mailboxFolderId, string syncId)
{
AirSyncDiagnostics.Assert(mailboxFolderId != null);
base.Add(mailboxFolderId, syncId);
}
public new void Add(ISyncItemId itemId, string syncId)
{
AirSyncDiagnostics.Assert(itemId != null);
base.Add(itemId, syncId);
}