// Token: 0x060002FE RID: 766 RVA: 0x0000FC2C File Offset: 0x0000DE2C
private void InitializeFromClientSecurityContext()
{
string proxyHeader = this.context.Request.ProxyHeader;
if (this.clientSecurityContextWrapper != null)
{
AirSyncDiagnostics.TraceInfo(ExTraceGlobals.RequestsTracer, null, "[AirSyncUser.InitializeFromClientSecurityContext]. clientSecurityContextWrapper is not null. calling dispose.");
this.clientSecurityContextWrapper.Dispose();
}
this.clientSecurityContextWrapper = (ClientSecurityContextWrapper)HttpRuntime.Cache.Get(proxyHeader);
if (this.clientSecurityContextWrapper == null)
{
AirSyncDiagnostics.TraceError <string>(ExTraceGlobals.RequestsTracer, null, "[AirSyncUser.InitializeFromClientSecurityContext] ProxyHeader key '{0}' was missing from HttpRuntime cache. Returning HttpStatusNeedIdentity.", proxyHeader);
this.context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "MissingCscCacheEntry");
AirSyncPermanentException ex = new AirSyncPermanentException((HttpStatusCode)441, StatusCode.None, null, false);
throw ex;
}
AirSyncDiagnostics.TraceDebug <string>(ExTraceGlobals.RequestsTracer, null, "[AirSyncUser.InitializeFromClientSecurityContext] ProxyHeader key '{0}' was found in the HttpRuntime cache. Reusing CSC for user.", proxyHeader);
string[] array = proxyHeader.Split(",".ToCharArray(), 2);
if (array.Length != 2)
{
this.context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "BadProxyHeader");
throw new AirSyncPermanentException(HttpStatusCode.BadRequest, StatusCode.InvalidCombinationOfIDs, null, false);
}
this.username = array[1];
((IAirSyncUser)this).InitializeADUser();
((IAirSyncUser)this).AcquireBudget();
}
protected override void ConvertSyncIdsToXsoIds(FolderCommand.FolderRequest folderRequest)
{
SyncCollection.CollectionTypes collectionType = AirSyncUtility.GetCollectionType(folderRequest.SyncServerId);
if (collectionType != SyncCollection.CollectionTypes.Mailbox && collectionType != SyncCollection.CollectionTypes.Unknown)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "DeleteOfVFolder");
AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_InvalidSyncKey, base.ConstructErrorXml(StatusCode.Sync_InvalidSyncKey), null, false);
throw ex;
}
SyncPermissions syncPermissions;
folderRequest.ServerId = base.GetXsoFolderId(folderRequest.SyncServerId, out syncPermissions);
if (folderRequest.ServerId == null)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "DeleteOfInvalidId");
AirSyncPermanentException ex2 = new AirSyncPermanentException(StatusCode.Sync_ProtocolError, base.ConstructErrorXml(StatusCode.Sync_ProtocolError), null, false);
throw ex2;
}
if (syncPermissions == SyncPermissions.FullAccess)
{
return;
}
if (base.Version < 140)
{
throw new InvalidOperationException("Pre-Version 14 device should not see a non-FullAccess folder! Folder Access Level: " + syncPermissions);
}
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "DeleteOfNonFullAccessFolder");
AirSyncPermanentException ex3 = new AirSyncPermanentException(StatusCode.Sync_InvalidSyncKey, base.ConstructErrorXml(StatusCode.Sync_InvalidSyncKey), null, false);
throw ex3;
}
// Token: 0x060000BB RID: 187 RVA: 0x0000858C File Offset: 0x0000678C
private void SetActiveSyncDeviceContainerPermissions(ActiveSyncDevices container)
{
ADDeviceManager.ReadStaticADData(this.protocolLogger);
RawSecurityDescriptor rawSecurityDescriptor = null;
ADNotificationAdapter.RunADOperation(delegate()
{
rawSecurityDescriptor = this.session.ReadSecurityDescriptor(container.Id);
});
if (rawSecurityDescriptor == null)
{
if (this.protocolLogger != null)
{
this.protocolLogger.SetValue(ProtocolLoggerData.Error, "ADObjectWithNoSecurityDescriptor");
}
AirSyncPermanentException ex = new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.ServerError, EASServerStrings.NullNTSD(container.Id.DistinguishedName), true);
throw ex;
}
AirSyncDiagnostics.TraceDebug <string>(this.tracer, this, "Setting ACL on device container for user \"{0}\".", this.userName);
ActiveDirectorySecurity acl = new ActiveDirectorySecurity();
byte[] array = new byte[rawSecurityDescriptor.BinaryLength];
rawSecurityDescriptor.GetBinaryForm(array, 0);
acl.SetSecurityDescriptorBinaryForm(array);
acl.AddAccessRule(new ActiveDirectoryAccessRule(ADDeviceManager.exchangeServersGroupSid, ActiveDirectoryRights.CreateChild | ActiveDirectoryRights.DeleteChild | ActiveDirectoryRights.ListChildren | ActiveDirectoryRights.ReadProperty | ActiveDirectoryRights.WriteProperty | ActiveDirectoryRights.ListObject, AccessControlType.Allow, ADDeviceManager.activeSyncDeviceClass, ActiveDirectorySecurityInheritance.None));
acl.AddAccessRule(new ActiveDirectoryAccessRule(ADDeviceManager.exchangeServersGroupSid, ActiveDirectoryRights.Delete | ActiveDirectoryRights.ReadProperty | ActiveDirectoryRights.WriteProperty | ActiveDirectoryRights.ListObject, AccessControlType.Allow, ActiveDirectorySecurityInheritance.Children, ADDeviceManager.activeSyncDeviceClass));
ADNotificationAdapter.RunADOperation(delegate()
{
this.session.SaveSecurityDescriptor(container, new RawSecurityDescriptor(acl.GetSecurityDescriptorBinaryForm(), 0));
});
}
// Token: 0x06000CE4 RID: 3300 RVA: 0x000453F8 File Offset: 0x000435F8
private void OnExecute()
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "MeetingRequest received. Processing the command ...");
base.XmlResponse = this.InitializeXmlResponse();
try
{
this.ParseXmlRequest();
this.ProcessCommand();
if (this.calendarSyncStateChangedFlag)
{
this.calendarSyncState.CustomVersion = new int?(9);
this.calendarSyncState.Commit();
}
}
catch (LocalizedException ex)
{
if (base.MailboxLogger != null)
{
base.MailboxLogger.SetData(MailboxLogDataName.MeetingResponseCommand_OnExecute_Exception, ex);
}
AirSyncPermanentException ex2 = ex as AirSyncPermanentException;
StatusCode status;
if (ex2 != null)
{
status = ex2.AirSyncStatusCode;
if (string.IsNullOrEmpty(ex2.ErrorStringForProtocolLogger))
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, ex2.GetType().Name);
}
}
else
{
status = StatusCode.Sync_ProtocolError;
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, ex.GetType().Name);
}
base.XmlResponse = this.InitializeXmlResponse();
this.AppendNonSuccessXmlNode(null, status, null, string.Format(CultureInfo.InvariantCulture, "Constructing the Xml response in case of LocalizedException: {0}", new object[]
{
ex.Message
}), false);
}
finally
{
if (this.calendarSyncState != null)
{
this.calendarSyncState.Dispose();
}
if (this.folderIdMappingSyncState != null)
{
this.folderIdMappingSyncState.Dispose();
}
}
}
protected override void ProcessCommand(FolderCommand.FolderRequest folderRequest, XmlDocument doc)
{
string namespaceURI = doc.DocumentElement.NamespaceURI;
DefaultFolderType defaultFolderType = base.MailboxSession.IsDefaultFolderType(folderRequest.ServerId);
AirSyncPermanentException ex;
if (defaultFolderType != DefaultFolderType.None)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "DeleteOfDefaultFolder");
ex = new AirSyncPermanentException(StatusCode.Sync_InvalidSyncKey, base.ConstructErrorXml(StatusCode.Sync_InvalidSyncKey), null, false);
throw ex;
}
AggregateOperationResult aggregateOperationResult = base.MailboxSession.Delete(DeleteItemFlags.SoftDelete, new StoreObjectId[]
{
folderRequest.ServerId
});
if (aggregateOperationResult.OperationResult != OperationResult.Failed)
{
base.FolderHierarchySync.RecordClientOperation(folderRequest.ServerId, ChangeType.Delete, null);
folderRequest.RecoverySyncKey = folderRequest.SyncKey;
folderRequest.SyncKey = base.GetNextNumber(folderRequest.SyncKey);
base.SyncStateChanged = true;
base.FolderHierarchySyncState[CustomStateDatumType.SyncKey] = new Int32Data(folderRequest.SyncKey);
base.FolderHierarchySyncState[CustomStateDatumType.RecoverySyncKey] = new Int32Data(folderRequest.RecoverySyncKey);
FolderIdMapping folderIdMapping = (FolderIdMapping)base.FolderIdMappingSyncState[CustomStateDatumType.IdMapping];
FolderTree folderTree = (FolderTree)base.FolderIdMappingSyncState[CustomStateDatumType.FullFolderTree];
MailboxSyncItemId folderId = MailboxSyncItemId.CreateForNewItem(folderRequest.ServerId);
folderTree.RemoveFolderAndChildren(folderId, folderIdMapping);
folderIdMapping.CommitChanges();
base.ProtocolLogger.IncrementValue("F", PerFolderProtocolLoggerData.ClientDeletes);
XmlNode xmlNode = doc.CreateElement("Status", namespaceURI);
xmlNode.InnerText = "1";
XmlNode xmlNode2 = doc.CreateElement("SyncKey", namespaceURI);
xmlNode2.InnerText = folderRequest.SyncKey.ToString(CultureInfo.InvariantCulture);
doc.DocumentElement.AppendChild(xmlNode);
doc.DocumentElement.AppendChild(xmlNode2);
return;
}
if (aggregateOperationResult.GroupOperationResults != null && aggregateOperationResult.GroupOperationResults.Length > 0 && aggregateOperationResult.GroupOperationResults[0] != null && aggregateOperationResult.GroupOperationResults[0].Exception is ObjectNotFoundException)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "DeleteOfNonExistentFolder");
ex = new AirSyncPermanentException(StatusCode.Sync_ProtocolError, base.ConstructErrorXml(StatusCode.Sync_ProtocolError), null, false);
throw ex;
}
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "DeleteFailed");
ex = new AirSyncPermanentException(StatusCode.Sync_ClientServerConversion, base.ConstructErrorXml(StatusCode.Sync_ClientServerConversion), null, false);
throw ex;
}
// Token: 0x06000C3C RID: 3132 RVA: 0x00040194 File Offset: 0x0003E394
protected override int InternalExecute(int count)
{
FolderSyncState folderSyncState = null;
int result;
try
{
string text = HttpUtility.UrlDecode(base.FileReference);
int num = text.IndexOf(':');
ItemIdMapping itemIdMapping = null;
if (num != -1 && num != text.LastIndexOf(':'))
{
string text2 = text.Substring(0, num);
SyncCollection.CollectionTypes collectionType = AirSyncUtility.GetCollectionType(text2);
if (collectionType != SyncCollection.CollectionTypes.Mailbox && collectionType != SyncCollection.CollectionTypes.Unknown)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "NoAttachmentsOnVItem");
AirSyncPermanentException ex = new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.InvalidCombinationOfIDs, null, false);
throw ex;
}
folderSyncState = base.SyncStateStorage.GetFolderSyncState(new MailboxSyncProviderFactory(base.Session), text2);
if (folderSyncState == null)
{
throw new ObjectNotFoundException(ServerStrings.MapiCannotOpenAttachmentId(text));
}
itemIdMapping = (ItemIdMapping)folderSyncState[CustomStateDatumType.IdMapping];
if (itemIdMapping == null)
{
throw new ObjectNotFoundException(ServerStrings.MapiCannotOpenAttachmentId(text));
}
}
int num2;
base.ContentType = AttachmentHelper.GetAttachment(base.Session, text, base.OutStream, base.MinRange, count, base.MaxAttachmentSize, itemIdMapping, base.RightsManagementSupport, out num2);
result = num2;
}
finally
{
if (folderSyncState != null)
{
folderSyncState.Dispose();
folderSyncState = null;
}
}
return(result);
}
// Token: 0x0600155E RID: 5470 RVA: 0x0007D460 File Offset: 0x0007B660
internal virtual void ParseXmlRequest()
{
string collectionId = this.CollectionId;
string itemId = this.ItemId;
string longId = this.LongId;
if (longId == null && itemId == null)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "NoMessageId");
throw new AirSyncPermanentException(HttpStatusCode.BadRequest, StatusCode.InvalidCombinationOfIDs, null, false);
}
if (longId != null && (itemId != null || collectionId != null))
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "TooManyIds");
string.Format("Send request isn't valid because it contains a LongId {0} and ItemId {1} or CollectionId {2}", longId, (itemId != null) ? itemId : "<null>", (collectionId != null) ? collectionId : "<null>");
AirSyncPermanentException ex = new AirSyncPermanentException(HttpStatusCode.BadRequest, StatusCode.InvalidCombinationOfIDs, null, false);
throw ex;
}
ExDateTime occurrence = this.Occurrence;
}
// Token: 0x06000300 RID: 768 RVA: 0x0000FD9C File Offset: 0x0000DF9C
private void InitializeFromLoggedOnIdentity()
{
if (((IAirSyncUser)this).WindowsIdentity.User == null)
{
AirSyncDiagnostics.TraceError(ExTraceGlobals.RequestsTracer, null, "[AirSyncUser.InitializeFromLoggedOnIdentity] Anonymous user is forbidden.");
this.context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "AnonymousUser");
AirSyncPermanentException ex = new AirSyncPermanentException(HttpStatusCode.Forbidden, StatusCode.UserCannotBeAnonymous, EASServerStrings.AnonymousAccessError, true);
throw ex;
}
this.windowsPrincipal = new WindowsPrincipal(((IAirSyncUser)this).WindowsIdentity);
this.username = this.context.Request.LogonUserName;
if (this.clientSecurityContextWrapper != null)
{
AirSyncDiagnostics.TraceInfo(ExTraceGlobals.RequestsTracer, null, "[AirSyncUser.InitializeFromLoggedOnIdentity]. clientSecurityContextWrapper is not null. calling dispose.");
this.clientSecurityContextWrapper.Dispose();
}
this.clientSecurityContextWrapper = ClientSecurityContextWrapper.FromWindowsIdentity(((IAirSyncUser)this).WindowsIdentity);
AirSyncDiagnostics.TraceError <string>(ExTraceGlobals.RequestsTracer, null, "[AirSyncUser.InitializeFromLoggedOnIdentity] Acquired CSC for user '{0}'", this.username);
((IAirSyncUser)this).InitializeADUser();
((IAirSyncUser)this).AcquireBudget();
}
private FolderTree.FolderInfo GetFolderInfo(ISyncItemId folderId)
{
if (folderId == null)
{
throw new ArgumentNullException("folderId");
}
if (!this.folderTree.ContainsKey(folderId))
{
this.TraceTree();
AirSyncPermanentException ex = new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.ServerError, null, false);
if (Command.CurrentCommand.ProtocolLogger != null)
{
string text = string.Format("{0}InvalidFolderIdException", Command.CurrentCommand.Request.CommandType);
Command.CurrentCommand.ProtocolLogger.SetValue(ProtocolLoggerData.Error, text);
ex.ErrorStringForProtocolLogger = text;
}
else
{
ex.ErrorStringForProtocolLogger = "BadFolderIdInFolderTree";
}
throw ex;
}
return(this.folderTree[folderId]);
}
// Token: 0x06001589 RID: 5513 RVA: 0x0007F070 File Offset: 0x0007D270
internal override Command.ExecutionState ExecuteCommand()
{
MessageItem clientMessage = null;
Item item = null;
MessageItem messageItem = null;
VersionedId versionedId = null;
CalendarItemBase calendarItemBase = null;
try
{
base.ValidateBody();
StoreObjectId defaultFolderId = base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Drafts);
clientMessage = MessageItem.Create(base.MailboxSession, defaultFolderId);
base.ParseMimeToMessage(clientMessage);
clientMessage.Save(SaveMode.NoConflictResolution);
clientMessage.Load();
versionedId = clientMessage.Id;
clientMessage.Dispose();
clientMessage = MessageItem.Bind(base.MailboxSession, versionedId);
item = base.GetSmartItem();
RmsTemplate rmsTemplate = null;
bool isReplyAll = false;
SendMailBase.IrmAction irmAction = base.GetIrmAction(delegate(RightsManagedMessageItem originalRightsManagedItem)
{
if (originalRightsManagedItem == null)
{
throw new ArgumentNullException("originalRightsManagedItem");
}
isReplyAll = this.IsIrmReplyAll(originalRightsManagedItem, clientMessage);
}, ref item, out rmsTemplate);
Microsoft.Exchange.Data.Storage.BodyFormat bodyFormat = clientMessage.Body.Format;
MeetingMessage meetingMessage = item as MeetingMessage;
string text;
if ((base.ReplaceMime || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage) && meetingMessage != null && !meetingMessage.IsDelegated() && (meetingMessage is MeetingCancellation || meetingMessage is MeetingRequest))
{
text = string.Empty;
}
else
{
using (TextReader textReader = clientMessage.Body.OpenTextReader(bodyFormat))
{
text = textReader.ReadToEnd();
}
Body body = (irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseInlineOriginalBody || irmAction == SendMailBase.IrmAction.ReusePublishingLicenseInlineOriginalBody) ? ((RightsManagedMessageItem)item).ProtectedBody : item.Body;
if (body.Format == Microsoft.Exchange.Data.Storage.BodyFormat.TextHtml)
{
if (bodyFormat == Microsoft.Exchange.Data.Storage.BodyFormat.TextPlain)
{
XmlDocument xmlDocument = new SafeXmlDocument();
XmlNode xmlNode = xmlDocument.CreateElement("PRE");
XmlAttribute xmlAttribute = xmlDocument.CreateAttribute("STYLE");
xmlAttribute.Value = "word-wrap:break-word; font-size:10.0pt; font-family:Tahoma; color:black";
xmlNode.Attributes.Append(xmlAttribute);
xmlNode.InnerText = text;
text = xmlNode.OuterXml;
}
bodyFormat = Microsoft.Exchange.Data.Storage.BodyFormat.TextHtml;
}
}
ReplyForwardConfiguration replyForwardConfiguration = new ReplyForwardConfiguration(bodyFormat);
replyForwardConfiguration.ConversionOptionsForSmime = AirSyncUtility.GetInboundConversionOptions();
replyForwardConfiguration.AddBodyPrefix(text);
if (item is MessageItem)
{
MessageItem messageItem2 = (MessageItem)item;
if (!messageItem2.IsReplyAllowed)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ReplyNotAllowed");
AirSyncPermanentException ex = new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.MessageReplyNotAllowed, null, false);
throw ex;
}
if (isReplyAll)
{
messageItem = messageItem2.CreateReplyAll(defaultFolderId, replyForwardConfiguration);
}
else
{
messageItem = messageItem2.CreateReply(defaultFolderId, replyForwardConfiguration);
}
if (irmAction == SendMailBase.IrmAction.CreateNewPublishingLicense || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseInlineOriginalBody || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage)
{
messageItem = base.GetRightsManagedReplyForward(messageItem, irmAction, rmsTemplate);
}
}
else if (item is CalendarItem)
{
CalendarItem item2 = (CalendarItem)item;
calendarItemBase = base.GetCalendarItemBaseToReplyOrForward(item2);
messageItem = calendarItemBase.CreateReply(defaultFolderId, replyForwardConfiguration);
}
if (messageItem == null)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ReplyFailed");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.MailSubmissionFailed, null, false);
}
base.CopyMessageContents(clientMessage, messageItem, true, (irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage) ? item : null);
base.SendMessage(messageItem);
}
finally
{
if (clientMessage != null)
{
if (versionedId != null)
{
base.MailboxSession.Delete(DeleteItemFlags.HardDelete, new StoreId[]
{
versionedId
});
}
clientMessage.Dispose();
}
if (item != null)
{
item.Dispose();
}
if (messageItem != null)
{
messageItem.Dispose();
}
if (calendarItemBase != null)
{
calendarItemBase.Dispose();
}
}
return(Command.ExecutionState.Complete);
}
// Token: 0x060008C8 RID: 2248 RVA: 0x00034B7C File Offset: 0x00032D7C
protected override void ProcessCommand(FolderCommand.FolderRequest folderRequest, XmlDocument doc)
{
if (FolderCommand.IsEmptyOrWhiteSpacesOnly(folderRequest.DisplayName))
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "EmptyDisplayName");
AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_NotificationGUID, base.ConstructErrorXml(StatusCode.Sync_NotificationGUID), null, false);
throw ex;
}
using (Folder folder = Folder.Create(base.MailboxSession, folderRequest.ParentId, StoreObjectType.Folder))
{
string namespaceURI = doc.DocumentElement.NamespaceURI;
folder.DisplayName = folderRequest.DisplayName;
string classNameFromType = AirSyncUtility.GetClassNameFromType(folderRequest.Type);
if (classNameFromType == null)
{
AirSyncPermanentException ex;
if (!this.IsValidSpecialFolderType(base.Version, folderRequest.Type))
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidFolderType");
ex = new AirSyncPermanentException(StatusCode.Sync_NotificationGUID, base.ConstructErrorXml(StatusCode.Sync_NotificationGUID), null, false);
throw ex;
}
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "CreateOfSpecialFolder");
ex = new AirSyncPermanentException(StatusCode.Sync_InvalidSyncKey, base.ConstructErrorXml(StatusCode.Sync_InvalidSyncKey), null, false);
throw ex;
}
else
{
folder.ClassName = classNameFromType;
try
{
folder.Save();
folder.Load();
}
catch (ObjectExistedException innerException)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "FolderExistsOnCreate");
AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_ProtocolVersionMismatch, base.ConstructErrorXml(StatusCode.Sync_ProtocolVersionMismatch), innerException, false);
throw ex;
}
catch (InvalidOperationException innerException2)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidOperationOnCreate");
AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_NotificationGUID, base.ConstructErrorXml(StatusCode.Sync_NotificationGUID), innerException2, false);
throw ex;
}
catch (ObjectValidationException innerException3)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ObjectValidationOnCreate");
AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_ProtocolVersionMismatch, base.ConstructErrorXml(StatusCode.Sync_ProtocolVersionMismatch), innerException3, false);
throw ex;
}
base.FolderHierarchySync.RecordClientOperation(folder.Id.ObjectId, ChangeType.Add, folder);
folderRequest.RecoverySyncKey = folderRequest.SyncKey;
folderRequest.SyncKey = base.GetNextNumber(folderRequest.SyncKey);
base.SyncStateChanged = true;
base.FolderHierarchySyncState[CustomStateDatumType.SyncKey] = new Int32Data(folderRequest.SyncKey);
base.FolderHierarchySyncState[CustomStateDatumType.RecoverySyncKey] = new Int32Data(folderRequest.RecoverySyncKey);
XmlNode xmlNode = doc.CreateElement("Status", namespaceURI);
xmlNode.InnerText = "1";
XmlNode xmlNode2 = doc.CreateElement("SyncKey", namespaceURI);
xmlNode2.InnerText = folderRequest.SyncKey.ToString(CultureInfo.InvariantCulture);
XmlNode xmlNode3 = doc.CreateElement("ServerId", namespaceURI);
FolderIdMapping folderIdMapping = (FolderIdMapping)base.FolderIdMappingSyncState[CustomStateDatumType.IdMapping];
ISyncItemId syncItemId = MailboxSyncItemId.CreateForNewItem(folder.Id.ObjectId);
xmlNode3.InnerText = folderIdMapping.Add(syncItemId);
folderIdMapping.CommitChanges();
doc.DocumentElement.AppendChild(xmlNode);
doc.DocumentElement.AppendChild(xmlNode2);
doc.DocumentElement.AppendChild(xmlNode3);
FolderTree folderTree = (FolderTree)base.FolderIdMappingSyncState[CustomStateDatumType.FullFolderTree];
folderTree.AddFolder(syncItemId);
if (!base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Root).Equals(folderRequest.ParentId))
{
ISyncItemId parentId = MailboxSyncItemId.CreateForNewItem(folderRequest.ParentId);
folderTree.LinkChildToParent(parentId, syncItemId);
}
base.ProtocolLogger.IncrementValue("F", PerFolderProtocolLoggerData.ClientAdds);
}
}
}
protected override void ProcessCommand(FolderCommand.FolderRequest folderRequest, XmlDocument doc)
{
DefaultFolderType defaultFolderType = base.MailboxSession.IsDefaultFolderType(folderRequest.ServerId);
if (defaultFolderType != DefaultFolderType.None)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "UpdateOfDefaultFolder");
AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_ProtocolVersionMismatch, base.ConstructErrorXml(StatusCode.Sync_ProtocolVersionMismatch), null, false);
throw ex;
}
if (FolderCommand.IsEmptyOrWhiteSpacesOnly(folderRequest.DisplayName))
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "UpdateOfEmptyDisplayName");
AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_NotificationGUID, base.ConstructErrorXml(StatusCode.Sync_NotificationGUID), null, false);
throw ex;
}
string namespaceURI = doc.DocumentElement.NamespaceURI;
using (Folder folder = Folder.Bind(base.MailboxSession, folderRequest.ServerId, null))
{
try
{
this.ProcessFolderNameChange(folderRequest, folder);
if (folderRequest.ParentId.Equals(folderRequest.ServerId))
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "UpdateUnderSelf");
AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_ProtocolVersionMismatch, base.ConstructErrorXml(StatusCode.Sync_ProtocolVersionMismatch), null, false);
throw ex;
}
if (!folderRequest.ParentId.Equals(folder.ParentId))
{
using (Folder.Bind(base.MailboxSession, folderRequest.ParentId, null))
{
}
AggregateOperationResult aggregateOperationResult = base.MailboxSession.Move(folderRequest.ParentId, new StoreObjectId[]
{
folderRequest.ServerId
});
if (aggregateOperationResult.OperationResult == OperationResult.Failed)
{
AirSyncPermanentException ex;
if (aggregateOperationResult.GroupOperationResults != null && aggregateOperationResult.GroupOperationResults[0] != null && aggregateOperationResult.GroupOperationResults[0].Exception is ObjectExistedException)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "UpdateOfNonExistentFolder");
ex = new AirSyncPermanentException(StatusCode.Sync_ProtocolVersionMismatch, base.ConstructErrorXml(StatusCode.Sync_ProtocolVersionMismatch), null, false);
throw ex;
}
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "UpdateFailed");
ex = new AirSyncPermanentException(StatusCode.Sync_ClientServerConversion, base.ConstructErrorXml(StatusCode.Sync_ClientServerConversion), null, false);
throw ex;
}
}
FolderTree folderTree = (FolderTree)base.FolderIdMappingSyncState[CustomStateDatumType.FullFolderTree];
ISyncItemId syncItemId = MailboxSyncItemId.CreateForNewItem(folderRequest.ServerId);
StoreObjectId defaultFolderId = base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Root);
ISyncItemId parentId = folderTree.GetParentId(syncItemId);
if (parentId != null)
{
folderTree.UnlinkChild(parentId, syncItemId);
}
if (!defaultFolderId.Equals(folderRequest.ParentId))
{
ISyncItemId parentId2 = MailboxSyncItemId.CreateForNewItem(folderRequest.ParentId);
folderTree.LinkChildToParent(parentId2, syncItemId);
}
}
catch (ObjectNotFoundException innerException)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ObjectNotFoundOnUpdate");
AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_ServerError, base.ConstructErrorXml(StatusCode.Sync_ServerError), innerException, false);
throw ex;
}
catch (ObjectExistedException innerException2)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ObjectExistedOnUpdate");
AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_ProtocolVersionMismatch, base.ConstructErrorXml(StatusCode.Sync_ProtocolVersionMismatch), innerException2, false);
throw ex;
}
base.FolderHierarchySync.RecordClientOperation(folder.Id.ObjectId, ChangeType.Change, folder);
folderRequest.RecoverySyncKey = folderRequest.SyncKey;
folderRequest.SyncKey = base.GetNextNumber(folderRequest.SyncKey);
base.SyncStateChanged = true;
base.FolderHierarchySyncState[CustomStateDatumType.SyncKey] = new Int32Data(folderRequest.SyncKey);
base.FolderHierarchySyncState[CustomStateDatumType.RecoverySyncKey] = new Int32Data(folderRequest.RecoverySyncKey);
base.ProtocolLogger.IncrementValue("F", PerFolderProtocolLoggerData.ClientChanges);
}
XmlNode xmlNode = doc.CreateElement("Status", namespaceURI);
xmlNode.InnerText = "1";
XmlNode xmlNode2 = doc.CreateElement("SyncKey", namespaceURI);
xmlNode2.InnerText = folderRequest.SyncKey.ToString(CultureInfo.InvariantCulture);
doc.DocumentElement.AppendChild(xmlNode);
doc.DocumentElement.AppendChild(xmlNode2);
}
internal override Command.ExecutionState ExecuteCommand()
{
string attachmentName = this.AttachmentName;
string value = string.Empty;
FolderSyncState folderSyncState = null;
AirSyncDiagnostics.TraceDebug <string>(ExTraceGlobals.RequestsTracer, this, "GetAttachmentCommand.Execute(). AttachmentName: '{0}'", attachmentName);
try
{
int incBy = 0;
if (base.Request.ContentType != null && !string.Equals(base.Request.ContentType, "message/rfc822", StringComparison.OrdinalIgnoreCase))
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidContentType");
throw new AirSyncPermanentException(HttpStatusCode.BadRequest, StatusCode.First140Error, null, false);
}
int num = attachmentName.IndexOf(':');
ItemIdMapping itemIdMapping = null;
if (num != -1 && num != attachmentName.LastIndexOf(':'))
{
folderSyncState = base.SyncStateStorage.GetFolderSyncState(new MailboxSyncProviderFactory(base.MailboxSession), attachmentName.Substring(0, num));
if (folderSyncState == null)
{
throw new ObjectNotFoundException(ServerStrings.MapiCannotOpenAttachmentId(attachmentName));
}
itemIdMapping = (ItemIdMapping)folderSyncState[CustomStateDatumType.IdMapping];
if (itemIdMapping == null)
{
throw new ObjectNotFoundException(ServerStrings.MapiCannotOpenAttachmentId(attachmentName));
}
}
PolicyData policyData = ADNotificationManager.GetPolicyData(base.User);
if (policyData != null && !policyData.AttachmentsEnabled)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "AttachmentsNotEnabledGetAttCmd");
throw new AirSyncPermanentException(HttpStatusCode.Forbidden, StatusCode.AccessDenied, null, false);
}
Unlimited <ByteQuantifiedSize> maxAttachmentSize = (policyData != null) ? policyData.MaxAttachmentSize : Unlimited <ByteQuantifiedSize> .UnlimitedValue;
value = AttachmentHelper.GetAttachment(base.MailboxSession, attachmentName, base.OutputStream, maxAttachmentSize, itemIdMapping, out incBy);
base.ProtocolLogger.IncrementValue(ProtocolLoggerData.Attachments);
base.ProtocolLogger.IncrementValueBy(ProtocolLoggerData.AttachmentBytes, incBy);
}
catch (FormatException innerException)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidAttachmentName");
AirSyncPermanentException ex = new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.InvalidIDs, innerException, false);
throw ex;
}
catch (ObjectNotFoundException innerException2)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "AttachmentNotFound");
AirSyncPermanentException ex2 = new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.None, innerException2, false);
throw ex2;
}
catch (IOException innerException3)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "IOException");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.None, innerException3, false);
}
catch (DataTooLargeException innerException4)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "AttachmentIsTooLarge");
PolicyData policyData2 = ADNotificationManager.GetPolicyData(base.User);
if (policyData2 != null)
{
policyData2.MaxAttachmentSize.ToString();
}
else
{
GlobalSettings.MaxDocumentDataSize.ToString(CultureInfo.InvariantCulture);
}
throw new AirSyncPermanentException(HttpStatusCode.RequestEntityTooLarge, StatusCode.AttachmentIsTooLarge, innerException4, false);
}
finally
{
if (folderSyncState != null)
{
folderSyncState.Dispose();
folderSyncState = null;
}
}
base.Context.Response.AppendHeader("Content-Type", value);
return(Command.ExecutionState.Complete);
}
