/// <summary> /// Define the scope and parameters of the synchronization download operation. /// </summary> /// <param name="serverId">A 32-bit signed integer represent the Identity of server.</param> /// <param name="folderHandleIndex">The server object handle index.</param> /// <param name="synchronizationType">The type of synchronization requested: contents or hierarchy.</param> /// <param name="option">Defines the parameters of a download operation.</param> /// <param name="synchronizationFlag">Flag structure that defines the parameters of the synchronization operation.</param> /// <param name="synchronizationExtraFlag">Extra flag structure that defines the parameters of the synchronization operation.</param> /// <param name="property">A list of properties and subobjects to exclude or include.</param> /// <param name="downloadcontextHandleIndex">Synchronization download context handle index.</param> /// <returns>Indicate the result of this ROP operation.</returns> public RopResult SynchronizationConfigure(int serverId, int folderHandleIndex, SynchronizationTypes synchronizationType, SendOptionAlls option, SynchronizationFlag synchronizationFlag, SynchronizationExtraFlag synchronizationExtraFlag, Sequence<string> property, out int downloadcontextHandleIndex) { // Initialize ROP data. downloadcontextHandleIndex = -1; uint objHandle = this.handleContainer[folderHandleIndex]; RopSynchronizationConfigureRequest synchronizationConfigureRequest; RopResult result = RopResult.InvalidParameter; switch (synchronizationType) { case SynchronizationTypes.Hierarchy: this.streamType = FastTransferStreamType.hierarchySync; break; case SynchronizationTypes.Contents: this.streamType = FastTransferStreamType.contentsSync; break; default: break; } PropertyTag[] propertyTags = new PropertyTag[property.Count]; for (int i = 0; i < property.Count; i++) { propertyTags[i] = this.propertyTagsDictionary[property[i]]; } this.synchroniztionFlag = synchronizationFlag; this.propertyTagForConfigure = propertyTags[0]; // Construct RopSynchronizationConfigure request. synchronizationConfigureRequest.RopId = (byte)RopId.RopSynchronizationConfigure; synchronizationConfigureRequest.LogonId = 0x00; synchronizationConfigureRequest.InputHandleIndex = 0x00; synchronizationConfigureRequest.OutputHandleIndex = 0x01; // 0x01,Indicates a contents synchronization.0x02,Indicates a hierarchy synchronization. synchronizationConfigureRequest.SynchronizationType = (byte)synchronizationType; synchronizationConfigureRequest.SendOptions = (byte)option; // Unicode synchronizationConfigureRequest.SynchronizationFlags = (ushort)synchronizationFlag; if (synchronizationType == SynchronizationTypes.Contents) { // Set RestrictionDataSize to 0x0000 to avoid the complex RestrictionData. synchronizationConfigureRequest.RestrictionDataSize = 0x0005; // If PidTagMessageClass exists synchronizationConfigureRequest.RestrictionData = new byte[] { 0x08, 0x1f, 0x00, 0x1a, 0x00 }; } else { // Set RestrictionDataSize to 0x0000 to avoid the complex RestrictionData. synchronizationConfigureRequest.RestrictionDataSize = 0x0000; synchronizationConfigureRequest.RestrictionData = new byte[0]; } synchronizationConfigureRequest.SynchronizationExtraFlags = (byte)synchronizationExtraFlag; synchronizationConfigureRequest.PropertyTagCount = (ushort)propertyTags.Length; synchronizationConfigureRequest.PropertyTags = propertyTags; if (this.Process(serverId, synchronizationConfigureRequest, objHandle) is RopSynchronizationConfigureResponse) { // Send request and get response. RopSynchronizationConfigureResponse synchronizationConfigureResponse = (RopSynchronizationConfigureResponse)this.Process(serverId, synchronizationConfigureRequest, objHandle); result = (RopResult)synchronizationConfigureResponse.ReturnValue; if (result == RopResult.Success) { downloadcontextHandleIndex = AdapterHelper.GetHandleIndex(); this.handleContainer.Add(downloadcontextHandleIndex, this.responseSOHs[synchronizationConfigureResponse.OutputHandleIndex]); if ((synchronizationExtraFlag & SynchronizationExtraFlag.OrderByDeliveryTime) != SynchronizationExtraFlag.OrderByDeliveryTime) { this.isOrderByDeliveryTimeExtraFlagNotSet = true; } if (this.lastChangeMadeByServer && (synchronizationExtraFlag & SynchronizationExtraFlag.CN) == SynchronizationExtraFlag.CN) { this.lastChangeMadeByClient = true; } } // Verify ROP SynchronizationConfigure this.VerifyRopSynchronizationConfigure(synchronizationConfigureRequest, synchronizationConfigureResponse); } else { // If the response type is not RopSynchronizationConfigureResponse it must be that the process method throughout a FormatException when sending RPC request buffer. result = RopResult.RpcFormat; } return result; }
/// <summary> /// Initializes a FastTransfer operation on a folder for downloading content and descendant subobjects for messages identified by a given set of IDs. /// </summary> /// <param name="serverId">A 32-bit signed integer represent the Identity of server.</param> /// <param name="sourceHandleIndex">Folder object handle index. </param> /// <param name="copyFlag">Defines parameters of the FastTransfer download operation.</param> /// <param name="option">Defines the parameters of a download operation.</param> /// <param name="messageIds">The list of MIDs the messages should copy.</param> /// <param name="copyMessageHandleIndex">The message handle index.</param> /// <returns>Indicate the result of this ROP operation.</returns> public RopResult FastTransferSourceCopyMessages(int serverId, int sourceHandleIndex, RopFastTransferSourceCopyMessagesCopyFlags copyFlag, SendOptionAlls option, Sequence<int> messageIds, out int copyMessageHandleIndex) { // Initialize ROP data RopResult result = RopResult.InvalidParameter; copyMessageHandleIndex = -1; this.streamType = FastTransferStreamType.MessageList; RopFastTransferSourceCopyMessagesRequest req; uint sourceHandle = this.handleContainer[sourceHandleIndex]; ushort idcount = (ushort)messageIds.Count; ulong[] messageId = new ulong[idcount]; int index = 0; foreach (int mID in messageIds) { messageId[index++] = this.objectIdContainer[mID]; } // Construct ROP request. req.RopId = 0x4B; req.LogonId = 0x00; req.InputHandleIndex = 0x00; req.OutputHandleIndex = 0x01; req.MessageIdCount = idcount; req.MessageIds = messageId; req.CopyFlags = (byte)copyFlag; req.SendOptions = (byte)option; // Stores message id and copy flag this.previousOperation = EnumFastTransferOperation.FastTransferSourceCopyMessage; this.messageIdForFastTransferSourceCopyMessages = (long)messageId[0]; this.copyFlagForFastTransferSourceCopyMessages = copyFlag; // Send request and get response. RopFastTransferSourceCopyMessagesResponse response = (RopFastTransferSourceCopyMessagesResponse)this.Process(serverId, req, sourceHandle); result = (RopResult)response.ReturnValue; if (result == RopResult.Success) { copyMessageHandleIndex = AdapterHelper.GetHandleIndex(); this.handleContainer.Add(copyMessageHandleIndex, this.responseSOHs[response.OutputHandleIndex]); } // Verify ROP FastTransferSourceCopyMessages this.VerifyRopFastTransferSourceCopyMessages(req, response); return result; }
/// <summary> /// Initializes a FastTransfer operation to download properties and descendant subobjects for a specified folder. /// </summary> /// <param name="serverId">A 32-bit signed integer represent the Identity of server.</param> /// <param name="sourceHandleIndex">Folder object handle index. </param> /// <param name="copyFlag">Defines parameters of the FastTransfer download operation.</param> /// <param name="option">Defines the parameters of a download operation.</param> /// <param name="copyFolderHandleIndex">The folder handle index.</param> /// <returns>Indicate the result of this ROP operation.</returns> public RopResult FastTransferSourceCopyFolder(int serverId, int sourceHandleIndex, CopyFolderCopyFlags copyFlag, SendOptionAlls option, out int copyFolderHandleIndex) { // Initialize return value. copyFolderHandleIndex = -1; RopResult result = RopResult.InvalidParameter; uint targetFolderHandle = this.handleContainer[sourceHandleIndex]; // Move flag only used in exchangeServer2007 if (!Common.IsRequirementEnabled(526001, this.Site) && copyFlag == CopyFolderCopyFlags.Move) { return result; } this.streamType = FastTransferStreamType.TopFolder; // Construct ROP request. RopFastTransferSourceCopyFolderRequest fastTransferSourceCopyFolderRequest; fastTransferSourceCopyFolderRequest.RopId = 0x4C; fastTransferSourceCopyFolderRequest.LogonId = 0x00; fastTransferSourceCopyFolderRequest.InputHandleIndex = 0x00; fastTransferSourceCopyFolderRequest.OutputHandleIndex = 0x01; fastTransferSourceCopyFolderRequest.CopyFlags = (byte)copyFlag; fastTransferSourceCopyFolderRequest.SendOptions = (byte)option; this.folderCopyFlag = copyFlag; // Send request and get response. RopFastTransferSourceCopyFolderResponse response = (RopFastTransferSourceCopyFolderResponse)this.Process(serverId, fastTransferSourceCopyFolderRequest, targetFolderHandle); result = (RopResult)response.ReturnValue; if (result == RopResult.Success) { copyFolderHandleIndex = AdapterHelper.GetHandleIndex(); this.handleContainer.Add(copyFolderHandleIndex, this.responseSOHs[response.OutputHandleIndex]); } // Verify ROP FastTransferSourceCopyFolder this.VerifyRopFastTransferSourceCopyFolder(fastTransferSourceCopyFolderRequest, response); return result; }
/// <summary> /// Initializes a FastTransfer operation to download content from a given messaging object and its descendant subobjects. /// </summary> /// <param name="serverId">A 32-bit signed integer represent the Identity of server.</param> /// <param name="sourceHandleIndex">Folder or message object handle index. </param> /// <param name="handleType">Type of object handle </param> /// <param name="level">Variable indicate whether copy the descendant subobjects.</param> /// <param name="copyFlag">Defines parameters of the FastTransfer download operation.</param> /// <param name="option">Defines the parameters of a download operation.</param> /// <param name="propertyTags">Array of properties and subobjects to exclude.</param> /// <param name="copyToHandleIndex">The properties handle index.</param> /// <returns>Indicate the result of this ROP operation.</returns> public RopResult FastTransferSourceCopyTo(int serverId, int sourceHandleIndex, InputHandleType handleType, bool level, CopyToCopyFlags copyFlag, SendOptionAlls option, Sequence<string> propertyTags, out int copyToHandleIndex) { // Initialize ROP returned value. RopResult result = RopResult.InvalidParameter; copyToHandleIndex = -1; ushort propertyCount = (ushort)propertyTags.Count; this.currentCopyFlag = copyFlag; // Get stream type. switch (handleType) { case InputHandleType.FolderHandle: this.streamType = FastTransferStreamType.folderContent; break; case InputHandleType.MessageHandle: this.streamType = FastTransferStreamType.MessageContent; break; case InputHandleType.AttachmentHandle: this.streamType = FastTransferStreamType.attachmentContent; break; default: break; } // Initialize input propertyTags PropertyTag[] messagePropertyTags = new PropertyTag[propertyCount]; for (int i = 0; i < propertyCount; i++) { messagePropertyTags[i] = this.propertyTagsDictionary[propertyTags[i]]; } // Stores the values for further verification this.previousOperation = EnumFastTransferOperation.FastTransferSourceCopyTo; this.propertyTags = messagePropertyTags; // Construct ROP request. uint sourceHandle = this.handleContainer[sourceHandleIndex]; RopFastTransferSourceCopyToRequest request; request.RopId = 0x4D; request.LogonId = 0X00; request.InputHandleIndex = 0x00; request.OutputHandleIndex = 0x01; // This value specifies the level at which the copy is occurring,Non-Zero: exclude all descendant subobjects from being copied request.Level = level ? (byte)1 : (byte)0; request.CopyFlags = (uint)copyFlag; request.SendOptions = (byte)option; request.PropertyTagCount = propertyCount; request.PropertyTags = messagePropertyTags; // Send request and get response. RopFastTransferSourceCopyToResponse response = (RopFastTransferSourceCopyToResponse)this.Process(serverId, request, sourceHandle); result = (RopResult)response.ReturnValue; if (result == RopResult.Success) { copyToHandleIndex = AdapterHelper.GetHandleIndex(); this.handleContainer.Add(copyToHandleIndex, this.responseSOHs[response.OutputHandleIndex]); } // Verify ROP FastTransferSourceCopyTo this.VerifyRopFastTransferSourceCopyTo(request, response); return result; }
/// <summary> /// Initializes a FastTransfer operation to download content from a given messaging object and its descendant subobjects. /// </summary> /// <param name="serverId">A 32-bit signed integer represent the Identity of server.</param> /// <param name="sourceHandleIndex">Folder or message object handle index. </param> /// <param name="handleType">Type of object handle. </param> /// <param name="level">Variable indicate whether copy the descendant subobjects.</param> /// <param name="copyFlag">Defines parameters of the FastTransfer download operation.</param> /// <param name="option">Defines the parameters of a download operation.</param> /// <param name="propertyTags">The list of properties and subobjects to exclude.</param> /// <param name="copyPropertiesHandleIndex">The properties handle index.</param> /// <returns>Indicate the result of this ROP operation.</returns> public RopResult FastTransferSourceCopyProperties(int serverId, int sourceHandleIndex, InputHandleType handleType, bool level, CopyPropertiesCopyFlags copyFlag, SendOptionAlls option, Sequence<string> propertyTags, out int copyPropertiesHandleIndex) { // Initialize ROP data. RopResult result = RopResult.InvalidParameter; RopFastTransferSourceCopyPropertiesRequest req; copyPropertiesHandleIndex = -1; uint sourceHandle = this.handleContainer[sourceHandleIndex]; // Get stream type. switch (handleType) { case InputHandleType.FolderHandle: this.streamType = FastTransferStreamType.folderContent; break; case InputHandleType.MessageHandle: this.streamType = FastTransferStreamType.MessageContent; break; case InputHandleType.AttachmentHandle: this.streamType = FastTransferStreamType.attachmentContent; break; default: break; } // Initialize input propertyTags. ushort propertyCount = (ushort)propertyTags.Count; PropertyTag[] messageSamplePropertyTags = new PropertyTag[propertyCount]; for (int i = 0; i < propertyCount; i++) { messageSamplePropertyTags[i] = this.propertyTagsDictionary[propertyTags[i]]; } this.previousOperation = EnumFastTransferOperation.FastTransferSourceCopyProperties; this.propertyTags = messageSamplePropertyTags; this.copySubObjects = !level; // Construct ROP request. req.RopId = 0x69; req.LogonId = 0x00; req.InputHandleIndex = 0x00; req.OutputHandleIndex = 0x01; // This value specifies the level at which the copy is occurring, which is specified in [MS-OXCROPS]. req.Level = (byte)(level ? 1 : 0); req.CopyFlags = (byte)copyFlag; req.SendOptions = (byte)option; req.PropertyTagCount = propertyCount; req.PropertyTags = messageSamplePropertyTags; // Send request and get response. RopFastTransferSourceCopyPropertiesResponse response = (RopFastTransferSourceCopyPropertiesResponse)this.Process(serverId, req, sourceHandle); result = (RopResult)response.ReturnValue; if (result == RopResult.Success) { copyPropertiesHandleIndex = AdapterHelper.GetHandleIndex(); this.handleContainer.Add(copyPropertiesHandleIndex, this.responseSOHs[response.OutputHandleIndex]); } // Verify ROP FastTransferSourceCopyProperties this.VerifyRopFastTransferSourceCopyProperties(req, response); return result; }
public static RopResult SynchronizationConfigure(int serverId, int folderHandleIndex, SynchronizationTypes synchronizationType, SendOptionAlls option, SynchronizationFlag synchronizationFlag, SynchronizationExtraFlag synchronizationExtraFlag, Sequence<string> property, out int downloadcontextHandleIndex) { // The contractions conditions. Condition.IsTrue(connections.Count > 0); Condition.IsTrue(connections.Keys.Contains(serverId)); Condition.IsTrue(connections[serverId].FolderContainer.Count > 0); // Initialize return value. RopResult result = RopResult.Success; downloadcontextHandleIndex = -1; if ((option & SendOptionAlls.Invalid) == SendOptionAlls.Invalid && (requirementContainer.ContainsKey(3463) && requirementContainer[3463])) { result = RopResult.InvalidParameter; return result; } // SynchronizationFlag MUST match the value of the Unicode flag from SendOptions field. if ((synchronizationFlag & SynchronizationFlag.Unicode) == SynchronizationFlag.Unicode) { Condition.IsTrue((option & SendOptionAlls.Unicode) == SendOptionAlls.Unicode); } // When SynchronizationType is 0X04 then Servers return 0x80070057. if (synchronizationType == SynchronizationTypes.InvalidParameter) { if (requirementContainer.ContainsKey(2695) && requirementContainer[2695]) { result = RopResult.NotSupported; } else { result = RopResult.InvalidParameter; ModelHelper.CaptureRequirement(2695, "[In Receiving a RopSynchronizationConfigure ROP Request] [SynchronizationType Constraints] Servers MUST return 0x80070057 if SynchronizationType is 0x04."); } } else if ((synchronizationFlag & SynchronizationFlag.Reserved) == SynchronizationFlag.Reserved) { // When SynchronizationType is Reserved then Servers MUST fail the ROP request. result = RopResult.RpcFormat; ModelHelper.CaptureRequirement(2180, "[In Receiving a RopSynchronizationConfigure ROP Request] [SynchronizationType Constraints] The server MUST fail the ROP request if the Reserved flag of the SynchronizationFlags field is set."); } else { // Get ConnectionData value. ConnectionData changeConnection = connections[serverId]; // Identify whether the CurrentFolder is existent or not. bool isCurrentFolderExist = false; // Identify whether the Current Folder is existent or not. foreach (AbstractFolder tempfolder in changeConnection.FolderContainer) { if (tempfolder.FolderHandleIndex == folderHandleIndex) { // Set the value to the variable when the current folder is existent. isCurrentFolderExist = true; } } // The condition of CurrentFolder is existent. if (isCurrentFolderExist) { // Initialize the Download information. AbstractDownloadInfo abstractDownloadInfo = new AbstractDownloadInfo { UpdatedState = new AbstractUpdatedState { CnsetRead = new Set<int>(), CnsetSeen = new Set<int>(), CnsetSeenFAI = new Set<int>(), IdsetGiven = new Set<int>() }, DownloadHandleIndex = AdapterHelper.GetHandleIndex() }; // Get the download Handle for download context. downloadcontextHandleIndex = abstractDownloadInfo.DownloadHandleIndex; ModelHelper.CaptureRequirement(669, "[In RopSynchronizationConfigure ROP Response Buffer]OutputServerObject: This value MUST be the synchronization download context."); // Record the flags. abstractDownloadInfo.Sendoptions = option; abstractDownloadInfo.SynchronizationType = synchronizationType; abstractDownloadInfo.Synchronizationflag = synchronizationFlag; abstractDownloadInfo.SynchronizationExtraflag = synchronizationExtraFlag; // Record the Property. abstractDownloadInfo.Property = property; // Record folder handle of related to the download context. abstractDownloadInfo.RelatedObjectHandleIndex = folderHandleIndex; switch (synchronizationType) { // Record synchronizationType value for condition of Synchronization type is Contents. case SynchronizationTypes.Contents: abstractDownloadInfo.AbstractFastTransferStreamType = FastTransferStreamType.contentsSync; abstractDownloadInfo.ObjectType = ObjectType.Folder; break; // Record synchronizationType value for condition of Synchronization type is Hierarchy. case SynchronizationTypes.Hierarchy: abstractDownloadInfo.AbstractFastTransferStreamType = FastTransferStreamType.hierarchySync; abstractDownloadInfo.ObjectType = ObjectType.Folder; break; default: // Condition ofsynchronizationType is invalid parameter. result = RopResult.InvalidParameter; break; } // Condition of the operation return success. if (result == RopResult.Success) { // Add the new value to DownloadContextContainer. changeConnection.DownloadContextContainer = changeConnection.DownloadContextContainer.Add(abstractDownloadInfo); connections[serverId] = changeConnection; priorDownloadOperation = PriorDownloadOperation.RopSynchronizationConfigure; priorOperation = MS_OXCFXICS.PriorOperation.RopSynchronizationConfigure; ModelHelper.CaptureRequirement( 641, @"[In RopSynchronizationConfigure] The RopSynchronizationConfigure ROP ([MS-OXCROPS] section 2.2.13.1) is used to define the synchronization scope and parameters of the synchronization download operation."); } } } return result; }
public static RopResult FastTransferSourceCopyFolder(int serverId, int folderHandleIndex, CopyFolderCopyFlags copyFlag, SendOptionAlls option, out int downloadContextHandleIndex) { // The contraction conditions. Condition.IsTrue(connections.Count > 0); Condition.IsTrue(connections.Keys.Contains(serverId)); // Initialize the return value. RopResult result = RopResult.InvalidParameter; // Modify the logical if ((option == SendOptionAlls.Invalid && (requirementContainer.ContainsKey(3487) && requirementContainer[3487])) || (copyFlag == CopyFolderCopyFlags.Invalid && (requirementContainer.ContainsKey(3483) && requirementContainer[3483]))) { // SendOption is Invalid parameter and CopyFolderCopyFlags is Invalid parameter. downloadContextHandleIndex = -1; return result; } else if (copyFlag == CopyFolderCopyFlags.Move && (requirementContainer.ContainsKey(526001) && !requirementContainer[526001])) { downloadContextHandleIndex = -1; ModelHelper.CaptureRequirement( 526001, @"[In Appendix A: Product Behavior] [CopyFlags] [When the flag name is Move, value is 0x01] Implementation does set the Move flag on a download operation to indicate the following: The server does not output any objects in a FastTransfer stream that the client does not have permissions to delete. <7> Section 2.2.3.1.1.4.1: In Exchange 2007, the Move bit flag is read by the server."); return result; } else { ConnectionData changeConnection = connections[serverId]; // Identify whether the current folder is existent or not. bool isFolderExist = false; foreach (AbstractFolder tempFolder in changeConnection.FolderContainer) { if (tempFolder.FolderHandleIndex == folderHandleIndex) { isFolderExist = true; } } Condition.IsTrue(isFolderExist); // Create a new download context. AbstractDownloadInfo downloadInfo = new AbstractDownloadInfo(); downloadContextHandleIndex = AdapterHelper.GetHandleIndex(); downloadInfo.DownloadHandleIndex = downloadContextHandleIndex; connections.Remove(serverId); // Record the FastTransferOperation and Stream Type. downloadInfo.AbstractFastTransferStreamType = FastTransferStreamType.TopFolder; downloadInfo.RelatedFastTransferOperation = EnumFastTransferOperation.FastTransferSourceCopyFolder; priorDownloadOperation = PriorDownloadOperation.RopFastTransferSourceCopyFolder; // Set value for new download context. downloadInfo.CopyFolderCopyFlag = copyFlag; downloadInfo.Sendoptions = option; downloadInfo.ObjectType = ObjectType.Folder; downloadInfo.RelatedObjectHandleIndex = folderHandleIndex; // Add new download context to downloadContainer. changeConnection.DownloadContextContainer = changeConnection.DownloadContextContainer.Add(downloadInfo); connections.Add(serverId, changeConnection); result = RopResult.Success; // If the server returns success result, it means the RopFastTransferSourceCopyFolder ROP initializes the FastTransfer operation successfully. And then this requirement can be captured. ModelHelper.CaptureRequirement( 502, @"[In RopFastTransferSourceCopyFolder ROP] The RopFastTransferSourceCopyFolder ROP ([MS-OXCROPS] section 2.2.12.4) initializes a FastTransfer operation to download properties and descendant subobjects for a specified folder."); } return result; }
public static RopResult FastTransferSourceCopyMessages(int serverId, int objHandleIndex, RopFastTransferSourceCopyMessagesCopyFlags copyFlag, SendOptionAlls option, Sequence<int> messageIds, out int downloadContextHandleIndex) { // The contraction conditions Condition.IsTrue(connections.Count > 0); Condition.IsTrue(connections.Keys.Contains(serverId)); // Initialize the return value. RopResult result = RopResult.InvalidParameter; if (option == SendOptionAlls.Invalid) { if (requirementContainer.ContainsKey(3479) && requirementContainer[3479]) { // SendOption flags value is invalid downloadContextHandleIndex = -1; return result; } } // Modify the logical if ((copyFlag & RopFastTransferSourceCopyMessagesCopyFlags.Unused3) == RopFastTransferSourceCopyMessagesCopyFlags.Unused3) { // CopyFlags is set to Unused3 downloadContextHandleIndex = -1; } else { // Identify whether the current folder is existent or not. ConnectionData changeConnection = connections[serverId]; bool isFolderExist = false; foreach (AbstractFolder tempFolder in changeConnection.FolderContainer) { if (tempFolder.FolderHandleIndex == objHandleIndex) { isFolderExist = true; } } Condition.IsTrue(isFolderExist); // Set value for new download context. AbstractDownloadInfo downloadInfo = new AbstractDownloadInfo(); downloadContextHandleIndex = AdapterHelper.GetHandleIndex(); downloadInfo.DownloadHandleIndex = downloadContextHandleIndex; connections.Remove(serverId); downloadInfo.AbstractFastTransferStreamType = FastTransferStreamType.MessageList; downloadInfo.CopyMessageCopyFlag = copyFlag; // Record the FastTransferOperation downloadInfo.RelatedFastTransferOperation = EnumFastTransferOperation.FastTransferSourceCopyMessage; priorDownloadOperation = PriorDownloadOperation.RopFastTransferSourceCopyMessage; // Set value for new download context. downloadInfo.Sendoptions = option; downloadInfo.RelatedObjectHandleIndex = objHandleIndex; downloadInfo.ObjectType = ObjectType.Folder; // Add new download context to DownloadContextContainer. changeConnection.DownloadContextContainer = changeConnection.DownloadContextContainer.Add(downloadInfo); connections.Add(serverId, changeConnection); priorOperation = MS_OXCFXICS.PriorOperation.RopFastTransferSourceCopyMessage; result = RopResult.Success; // If the server returns success result, it means the RopFastTransferSourceCopyMessages ROP initializes the FastTransfer operation successfully. And then this requirement can be captured. ModelHelper.CaptureRequirement( 3125, @"[In RopFastTransferSourceCopyMessages ROP] The RopFastTransferSourceCopyMessages ROP ([MS-OXCROPS] section 2.2.12.5) initializes a FastTransfer operation on a folder for downloading content and descendant subobjects of messages identified by a set of MID structures ([MS-OXCDATA] section 2.2.1.2)."); } return result; }
public static RopResult FastTransferSourceCopyProperties(int serverId, int objHandleIndex, InputHandleType handleType, bool level, CopyPropertiesCopyFlags copyFlag, SendOptionAlls option, Sequence<string> propertyTags, out int downloadContextHandleIndex) { // The contraction conditions Condition.IsTrue(connections.Count > 0); Condition.IsTrue(connections.Keys.Contains(serverId)); // Initialize the return value. RopResult result = RopResult.InvalidParameter; // SendOptionAll value is Invalid parameter if ((option == SendOptionAlls.Invalid && (requirementContainer.ContainsKey(3470) && requirementContainer[3470])) || (copyFlag == CopyPropertiesCopyFlags.Invalid && (requirementContainer.ContainsKey(3466) && requirementContainer[3466]))) { downloadContextHandleIndex = -1; } else if (((copyFlag & CopyPropertiesCopyFlags.Move) == CopyPropertiesCopyFlags.Move) && (requirementContainer.ContainsKey(3466) && requirementContainer[3466])) { // CopyPropertiesCopyFlags value is Move. result = RopResult.NotImplemented; downloadContextHandleIndex = -1; } else { // Create a new download context. AbstractDownloadInfo downloadInfo = new AbstractDownloadInfo(); ConnectionData changeConnection = connections[serverId]; bool isObjExist = false; connections.Remove(serverId); if (handleType == InputHandleType.MessageHandle) { foreach (AbstractMessage temp in changeConnection.MessageContainer) { if (temp.MessageHandleIndex == objHandleIndex) { isObjExist = true; } } Condition.IsTrue(isObjExist); // Set value for new download context. downloadContextHandleIndex = AdapterHelper.GetHandleIndex(); downloadInfo.DownloadHandleIndex = downloadContextHandleIndex; downloadInfo.AbstractFastTransferStreamType = FastTransferStreamType.MessageContent; // Record the FastTransferOperation downloadInfo.RelatedFastTransferOperation = EnumFastTransferOperation.FastTransferSourceCopyProperties; priorDownloadOperation = PriorDownloadOperation.RopFastTransferSourceCopyProperties; // Set value for new download context. downloadInfo.CopyPropertiesCopyFlag = copyFlag; downloadInfo.Property = propertyTags; downloadInfo.Sendoptions = option; downloadInfo.RelatedObjectHandleIndex = objHandleIndex; downloadInfo.ObjectType = ObjectType.Message; downloadInfo.IsLevelTrue = level; // Add new download context to DownloadContextContainer. changeConnection.DownloadContextContainer = changeConnection.DownloadContextContainer.Add(downloadInfo); } else if (handleType == InputHandleType.FolderHandle) { // Find current folder. foreach (AbstractFolder temp in changeConnection.FolderContainer) { if (temp.FolderHandleIndex == objHandleIndex) { isObjExist = true; } } Condition.IsTrue(isObjExist); // Set value for new download context. downloadContextHandleIndex = AdapterHelper.GetHandleIndex(); downloadInfo.DownloadHandleIndex = downloadContextHandleIndex; downloadInfo.AbstractFastTransferStreamType = FastTransferStreamType.folderContent; // Record the FastTransferOperation downloadInfo.RelatedFastTransferOperation = EnumFastTransferOperation.FastTransferSourceCopyProperties; priorDownloadOperation = PriorDownloadOperation.RopFastTransferSourceCopyProperties; // Set value for new download context. downloadInfo.CopyPropertiesCopyFlag = copyFlag; downloadInfo.Property = propertyTags; downloadInfo.Sendoptions = option; downloadInfo.RelatedObjectHandleIndex = objHandleIndex; downloadInfo.ObjectType = ObjectType.Folder; // Add new download context to DownloadContextContainer. changeConnection.DownloadContextContainer = changeConnection.DownloadContextContainer.Add(downloadInfo); } else { // Find the current Attachment foreach (AbstractAttachment temp in changeConnection.AttachmentContainer) { if (temp.AttachmentHandleIndex == objHandleIndex) { isObjExist = true; } } Condition.IsTrue(isObjExist); // Set value for new download context. downloadContextHandleIndex = AdapterHelper.GetHandleIndex(); downloadInfo.DownloadHandleIndex = downloadContextHandleIndex; downloadInfo.AbstractFastTransferStreamType = FastTransferStreamType.attachmentContent; // Record the FastTransferOperation downloadInfo.RelatedFastTransferOperation = EnumFastTransferOperation.FastTransferSourceCopyProperties; priorDownloadOperation = PriorDownloadOperation.RopFastTransferSourceCopyProperties; // Set value for new download context. downloadInfo.CopyPropertiesCopyFlag = copyFlag; downloadInfo.Property = propertyTags; downloadInfo.Sendoptions = option; downloadInfo.ObjectType = ObjectType.Attachment; downloadInfo.RelatedObjectHandleIndex = objHandleIndex; // Add new download context to DownloadContextContainer. changeConnection.DownloadContextContainer = changeConnection.DownloadContextContainer.Add(downloadInfo); } connections.Add(serverId, changeConnection); result = RopResult.Success; // If the server returns success result, it means the RopFastTransferSourceCopyProperties ROP initializes the FastTransfer operation successfully. And then this requirement can be captured. ModelHelper.CaptureRequirement( 431, @"[In RopFastTransferSourceCopyProperties ROP] The RopFastTransferSourceCopyProperties ROP ([MS-OXCROPS] section 2.2.12.7) initializes a FastTransfer operation to download content from a specified messaging object and its descendant sub objects."); } return result; }
public static RopResult FastTransferSourceCopyTo(int serverId, int objHandleIndex, InputHandleType handleType, bool level, CopyToCopyFlags copyFlag, SendOptionAlls option, Sequence<string> propertyTags, out int downloadContextHandleIndex) { // The contraction conditions. Condition.IsTrue(connections.Count > 0); Condition.IsTrue(connections.Keys.Contains(serverId)); // Initialize the return value. RopResult result = RopResult.InvalidParameter; // The copyFlag conditions. if (((copyFlag == CopyToCopyFlags.Invalid && (requirementContainer.ContainsKey(3445) && requirementContainer[3445])) || (option == SendOptionAlls.Invalid && (requirementContainer.ContainsKey(3463) && requirementContainer[3463]))) || ((copyFlag & CopyToCopyFlags.Move) == CopyToCopyFlags.Move && (requirementContainer.ContainsKey(3442001) && requirementContainer[3442001])) || ((copyFlag & CopyToCopyFlags.Move) == CopyToCopyFlags.Move && (requirementContainer.ContainsKey(3442003) && requirementContainer[3442003]))) { downloadContextHandleIndex = -1; if ((copyFlag & CopyToCopyFlags.Move) == CopyToCopyFlags.Move) { // CopyToCopyFlags value is Move. if (requirementContainer.ContainsKey(3442001) && requirementContainer[3442001]) { // When the ROP return invalid parameter this requirement verified. ModelHelper.CaptureRequirement( 3442001, @"[In Appendix A: Product Behavior] Implementation does not support. <31> Section 3.2.5.8.1.1: Exchange 2010 and Exchange 2013 do not support the Move flag for the RopFastTransferSourceCopyTo ROP (section 2.2.3.1.1.1)."); } if (requirementContainer.ContainsKey(3442003) && requirementContainer[3442003]) { result = RopResult.InvalidParameter; // When the ROP return invalid parameter this requirement verified. ModelHelper.CaptureRequirement( 3442003, @"[In Appendix A: Product Behavior] If the server receives the Move flag, implementation does fail the operation with an error code InvalidParameter (0x80070057). <31> Section 3.2.5.8.1.1: The server sets the value of the ReturnValue field to InvalidParameter (0x80070057) if it receives this flag [Move flag].(Microsoft Exchange Server 2010, Exchange Server 2013 and Exchange Server 2016 follow this behavior.)"); } } return result; } else { // Create a new download context AbstractDownloadInfo downloadInfo = new AbstractDownloadInfo(); bool isObjExist = false; // Get value of ConnectionData ConnectionData changeConnection = connections[serverId]; connections.Remove(serverId); // Find current message if (handleType == InputHandleType.MessageHandle) { foreach (AbstractMessage temp in changeConnection.MessageContainer) { if (temp.MessageHandleIndex == objHandleIndex) { isObjExist = true; } } Condition.IsTrue(isObjExist); // Set value for new download context. downloadInfo.DownloadHandleIndex = AdapterHelper.GetHandleIndex(); downloadContextHandleIndex = downloadInfo.DownloadHandleIndex; downloadInfo.Sendoptions = option; downloadInfo.Property = propertyTags; downloadInfo.CopyToCopyFlag = copyFlag; downloadInfo.IsLevelTrue = level; // Record FastTransfer Operation. downloadInfo.RelatedFastTransferOperation = EnumFastTransferOperation.FastTransferSourceCopyTo; downloadInfo.AbstractFastTransferStreamType = FastTransferStreamType.MessageContent; downloadInfo.ObjectType = ObjectType.Message; downloadInfo.RelatedObjectHandleIndex = objHandleIndex; priorDownloadOperation = PriorDownloadOperation.RopFastTransferSourceCopyTo; // Add new download context to downloadContext Container. changeConnection.DownloadContextContainer = changeConnection.DownloadContextContainer.Add(downloadInfo); } else if (handleType == InputHandleType.FolderHandle) { // Find current folder. foreach (AbstractFolder temp in changeConnection.FolderContainer) { if (temp.FolderHandleIndex == objHandleIndex) { isObjExist = true; } } Condition.IsTrue(isObjExist); // Set value for new download context. downloadInfo.DownloadHandleIndex = AdapterHelper.GetHandleIndex(); downloadContextHandleIndex = downloadInfo.DownloadHandleIndex; downloadInfo.Sendoptions = option; downloadInfo.Property = propertyTags; downloadInfo.CopyToCopyFlag = copyFlag; // Record FastTransfer Operation downloadInfo.RelatedFastTransferOperation = EnumFastTransferOperation.FastTransferSourceCopyTo; downloadInfo.AbstractFastTransferStreamType = FastTransferStreamType.folderContent; downloadInfo.ObjectType = ObjectType.Folder; downloadInfo.RelatedObjectHandleIndex = objHandleIndex; priorDownloadOperation = PriorDownloadOperation.RopFastTransferSourceCopyTo; // Add new download context to DownloadContextContainer changeConnection.DownloadContextContainer = changeConnection.DownloadContextContainer.Add(downloadInfo); } else { // Find current attachment foreach (AbstractAttachment temp in changeConnection.AttachmentContainer) { if (temp.AttachmentHandleIndex == objHandleIndex) { isObjExist = true; } } Condition.IsTrue(isObjExist); // Set value for new download context. downloadInfo.DownloadHandleIndex = AdapterHelper.GetHandleIndex(); downloadContextHandleIndex = downloadInfo.DownloadHandleIndex; downloadInfo.Sendoptions = option; downloadInfo.Property = propertyTags; downloadInfo.CopyToCopyFlag = copyFlag; // Record FastTransfer Operation downloadInfo.RelatedFastTransferOperation = EnumFastTransferOperation.FastTransferSourceCopyTo; downloadInfo.AbstractFastTransferStreamType = FastTransferStreamType.attachmentContent; downloadInfo.ObjectType = ObjectType.Attachment; downloadInfo.RelatedObjectHandleIndex = objHandleIndex; priorDownloadOperation = PriorDownloadOperation.RopFastTransferSourceCopyTo; // Add new download context to DownloadContextContainer changeConnection.DownloadContextContainer = changeConnection.DownloadContextContainer.Add(downloadInfo); } connections.Add(serverId, changeConnection); result = RopResult.Success; ModelHelper.CaptureRequirement( 361, @"[In RopFastTransferSourceCopyTo ROP] The RopFastTransferSourceCopyTo ROP ([MS-OXCROPS] section 2.2.12.6) initializes a FastTransfer operation to download content from a given messaging object and its descendant subobjects."); if ((copyFlag & CopyToCopyFlags.Move) == CopyToCopyFlags.Move) { if (requirementContainer.ContainsKey(3442002) && requirementContainer[3442002]) { ModelHelper.CaptureRequirement( 3442002, @"[In Appendix A: Product Behavior] Implementation does support Move flag [for the RopFastTransferSourceCopyTo ROP]. (Microsoft Exchange Server 2007 follow this behavior.)"); } if (requirementContainer.ContainsKey(3442004) && requirementContainer[3442004]) { ModelHelper.CaptureRequirement( 3442004, @"[In Appendix A: Product Behavior] If the server receives the Move flag, implementation does not fail the operation.(<31> Section 3.2.5.8.1.1: Microsoft Exchange Server 2007 follows this behavior.)"); } } } return result; }