/// <summary>
/// Verify whether the specified folder was soft deleted.
/// </summary>
/// <param name="folderId">The specified folder ID.</param>
/// <returns>Return a Boolean value indicates whether the specified folder was soft deleted.</returns>
protected bool IsFolderSoftDeleted(ulong folderId)
{
bool folderDeleted = this.IsFolderDeleted(folderId);
bool folderSoftDeleted = false;
if (folderDeleted)
{
RopOpenFolderRequest openFolderRequest = new RopOpenFolderRequest
{
RopId = (byte)RopId.RopOpenFolder,
LogonId = Constants.CommonLogonId,
InputHandleIndex = Constants.CommonInputHandleIndex,
OutputHandleIndex = Constants.CommonOutputHandleIndex,
OpenModeFlags = (byte)FolderOpenModeFlags.OpenSoftDeleted,
FolderId = folderId
};
RopOpenFolderResponse openFolderResponse = this.Adapter.OpenFolder(openFolderRequest, this.LogonHandle, ref this.responseHandles);
if (openFolderResponse.ReturnValue == 0)
{
folderSoftDeleted = true;
}
}
return(folderSoftDeleted);
}
/// <summary>
/// Log on mailbox with specified user.
/// </summary>
/// <param name="testUser">Identify the user to log on to the server.</param>
public void LogonMailbox(TestUser testUser)
{
this.testUser = testUser;
RopLogonResponse logonResponse = new RopLogonResponse();
if (testUser == TestUser.TestUser1)
{
this.OxoruleAdapter.Connect(ConnectionType.PrivateMailboxServer, this.User1Name, this.User1ESSDN, this.User1Password);
// Logon to private mailbox.
this.LogonHandle = this.OxoruleAdapter.RopLogon(LogonType.Mailbox, this.User1ESSDN, out logonResponse);
}
else
{
this.OxoruleAdapter.Connect(ConnectionType.PrivateMailboxServer, this.User2Name, this.User2ESSDN, this.User2Password);
// Logon to private mailbox.
this.LogonHandle = this.OxoruleAdapter.RopLogon(LogonType.Mailbox, this.User2ESSDN, out logonResponse);
}
// Get the mailbox's GUID
this.MailboxGUID = logonResponse.MailboxGuid;
// Get folder ids.
this.InboxFolderID = logonResponse.FolderIds[4];
this.DAFFolderID = logonResponse.FolderIds[1];
outBoxFolderID = logonResponse.FolderIds[5];
sentItemsFolderID = logonResponse.FolderIds[6];
// Open inbox and get inbox folder handle.
RopOpenFolderResponse openInboxResponse = new RopOpenFolderResponse();
this.InboxFolderHandle = this.OxoruleAdapter.RopOpenFolder(this.LogonHandle, this.InboxFolderID, out openInboxResponse);
// Open DAF folder and get daf folder handle.
RopOpenFolderResponse openDAFResponse = new RopOpenFolderResponse();
this.DAFFolderHandle = this.OxoruleAdapter.RopOpenFolder(this.LogonHandle, this.DAFFolderID, out openDAFResponse);
// Open outbox folder and get outbox folder handle.
RopOpenFolderResponse openOutBoxResponse = new RopOpenFolderResponse();
outBoxFolderHandle = this.OxoruleAdapter.RopOpenFolder(this.LogonHandle, outBoxFolderID, out openOutBoxResponse);
// Open sent items folder and get sent items folder handle.
RopOpenFolderResponse openSentItemsFolderResponse = new RopOpenFolderResponse();
sentItemsFolderHandle = this.OxoruleAdapter.RopOpenFolder(this.LogonHandle, sentItemsFolderID, out openSentItemsFolderResponse);
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXORULE_R508");
// Verify MS-OXORULE requirement: MS-OXORULE_R508.
// If the DAF folder handle is not zero. It means the DAF has been created.
Site.CaptureRequirementIfAreNotEqual <ulong>(
0,
this.DAFFolderHandle,
508,
@"[In Initialization] Prior to any client connecting to a mailbox, the server MUST ensure that the DAF has been created for that mailbox as specified in [MS-OXOSFLD] section 3.1.4.1.");
}
/// <summary>
/// Open a specified message in specified folder.
/// </summary>
/// <param name="messageId">The specified message ID.</param>
/// <param name="folderId">The specified folder ID.</param>
/// <param name="openModeFlags">OpenModeFlags for RopOpenMessage.</param>
/// <returns>The response of RopOpenMessage ROP operation.</returns>
protected RopOpenMessageResponse OpenMessage(ulong messageId, ulong folderId, MessageOpenModeFlags openModeFlags)
{
RopOpenFolderRequest openFolderRequest = new RopOpenFolderRequest
{
RopId = (byte)RopId.RopOpenFolder,
LogonId = Constants.CommonLogonId,
InputHandleIndex = Constants.CommonInputHandleIndex,
OutputHandleIndex = Constants.CommonOutputHandleIndex,
OpenModeFlags = (byte)FolderOpenModeFlags.None,
FolderId = folderId
};
RopOpenFolderResponse openFolderResponse = this.Adapter.OpenFolder(openFolderRequest, this.LogonHandle, ref this.responseHandles);
uint folderHandle = this.responseHandles[0][openFolderResponse.OutputHandleIndex];
RopOpenMessageRequest openMessageRequest = new RopOpenMessageRequest();
object ropResponse = null;
openMessageRequest.RopId = (byte)RopId.RopOpenMessage;
openMessageRequest.LogonId = Constants.CommonLogonId;
openMessageRequest.InputHandleIndex = Constants.CommonInputHandleIndex;
openMessageRequest.OutputHandleIndex = Constants.CommonOutputHandleIndex;
openMessageRequest.OpenModeFlags = (byte)openModeFlags;
openMessageRequest.FolderId = folderId;
openMessageRequest.MessageId = messageId;
openMessageRequest.CodePageId = 0x0fff;
this.Adapter.DoRopCall(openMessageRequest, folderHandle, ref ropResponse, ref this.responseHandles);
return((RopOpenMessageResponse)ropResponse);
}
/// <summary>
/// This ROP opens an existing folder in a mailbox.
/// </summary>
/// <param name="handle">The handle to operate</param>
/// <param name="openFolderResponse">The response of this ROP</param>
/// <param name="folderId">The identifier of the folder to be opened.</param>
/// <param name="needVerify">Whether need to verify the response</param>
/// <returns>The handle of the opened folder</returns>
private uint RopOpenFolder(uint handle, out RopOpenFolderResponse openFolderResponse, ulong folderId, bool needVerify)
{
this.rawDataValue = null;
this.responseValue = null;
this.responseSOHsValue = null;
RopOpenFolderRequest openFolderRequest = new RopOpenFolderRequest()
{
RopId = (byte)RopId.RopOpenFolder,
LogonId = LogonId,
InputHandleIndex = (byte)HandleIndex.FirstIndex,
OutputHandleIndex = (byte)HandleIndex.SecondIndex,
FolderId = folderId,
// Open an existing folder with None value for OpenModeFlags flag.
OpenModeFlags = (byte)FolderOpenModeFlags.None
};
this.responseSOHsValue = this.ProcessSingleRop(openFolderRequest, handle, ref this.responseValue, ref this.rawDataValue, RopResponseType.SuccessResponse);
openFolderResponse = (RopOpenFolderResponse)this.responseValue;
if (needVerify)
{
this.Site.Assert.AreEqual((uint)RopResponseType.SuccessResponse, openFolderResponse.ReturnValue, string.Format("RopOpenFolderResponse Failed! Error: 0x{0:X8}", openFolderResponse.ReturnValue));
}
return(this.responseSOHsValue[0][openFolderResponse.OutputHandleIndex]);
}
/// <summary>
/// Opens an existing folder.
/// </summary>
/// <param name="inputHandle">The input Server object for this operation is a Logon object or a Folder object that represents the object to be opened.</param>
/// <param name="folderId">The folder ID specifies the folder to be opened.</param>
/// <param name="folderHandle">A Folder object that represents the folder that was opened.</param>
/// <returns>The RopOpenFolder ROP response buffer.</returns>
protected RopOpenFolderResponse OpenFolder(uint inputHandle, ulong folderId, ref uint folderHandle)
{
RopOpenFolderRequest openFolderRequest = new RopOpenFolderRequest
{
RopId = (byte)RopId.RopOpenFolder,
LogonId = Constants.CommonLogonId,
InputHandleIndex = Constants.CommonInputHandleIndex,
OutputHandleIndex = Constants.CommonOutputHandleIndex,
OpenModeFlags = (byte)FolderOpenModeFlags.None,
FolderId = folderId
};
RopOpenFolderResponse openFolderResponse = this.Adapter.OpenFolder(openFolderRequest, inputHandle, ref this.responseHandles);
folderHandle = this.responseHandles[0][openFolderResponse.OutputHandleIndex];
return(openFolderResponse);
}
/// <summary>
/// Opens an existing folder.
/// </summary>
/// <param name="ropOpenFolderRequest">RopOpenFolderRequest object.</param>
/// <param name="insideObjHandle">Server object handle in RopOpenFolderRequest.</param>
/// <param name="responseSOHTable">Server objects handles in RopOpenFolderResponse.</param>
/// <returns>RopOpenFolderResponse object.</returns>
public RopOpenFolderResponse OpenFolder(RopOpenFolderRequest ropOpenFolderRequest, uint insideObjHandle, ref List <List <uint> > responseSOHTable)
{
object temp = new object();
ropOpenFolderRequest.RopId = (byte)RopId.RopOpenFolder;
ropOpenFolderRequest.LogonId = Constants.CommonLogonId;
ropOpenFolderRequest.InputHandleIndex = Constants.CommonInputHandleIndex;
ropOpenFolderRequest.OutputHandleIndex = Constants.CommonOutputHandleIndex;
this.ExcuteRopCall((ISerializable)ropOpenFolderRequest, insideObjHandle, ref temp, ref responseSOHTable, ref this.rawData);
RopOpenFolderResponse ropOpenFolderResponse = (RopOpenFolderResponse)temp;
#region Capture Code
// The ReturnValue equal to 0x00000000 indicate ROP operation success
if (0x00000000 == ropOpenFolderResponse.ReturnValue)
{
this.VerifyRopOpenFolder(ropOpenFolderResponse);
}
#endregion
return(ropOpenFolderResponse);
}
/// <summary>
/// Initialize a generic folder under inbox as a root folder for test.
/// </summary>
protected void GenericFolderInitialization()
{
RopLogonResponse logonResponse = this.Logon(LogonFlags.Private, out this.logonHandle);
#region Open the inbox folder.
RopOpenFolderRequest openFolderRequest = new RopOpenFolderRequest
{
RopId = (byte)RopId.RopOpenFolder,
LogonId = Constants.CommonLogonId,
InputHandleIndex = Constants.CommonInputHandleIndex,
OutputHandleIndex = Constants.CommonOutputHandleIndex,
FolderId = logonResponse.FolderIds[Constants.InboxIndex],
OpenModeFlags = (byte)FolderOpenModeFlags.OpenSoftDeleted
};
// Use the logon object as input handle here.
RopOpenFolderResponse openFolderResponse = this.Adapter.OpenFolder(openFolderRequest, this.LogonHandle, ref this.responseHandles);
this.inboxFolderHandle = this.responseHandles[0][openFolderResponse.OutputHandleIndex];
#endregion
#region Create a generic folder for test.
RopCreateFolderRequest createFolderRequest = new RopCreateFolderRequest();
RopCreateFolderResponse createFolderResponse = new RopCreateFolderResponse();
createFolderRequest.RopId = (byte)RopId.RopCreateFolder;
createFolderRequest.LogonId = Constants.CommonLogonId;
createFolderRequest.InputHandleIndex = Constants.CommonInputHandleIndex;
createFolderRequest.OutputHandleIndex = Constants.CommonOutputHandleIndex;
createFolderRequest.FolderType = 0x01;
createFolderRequest.UseUnicodeStrings = 0x0;
createFolderRequest.OpenExisting = 0x01;
createFolderRequest.Reserved = 0x0;
createFolderRequest.DisplayName = Encoding.ASCII.GetBytes(this.RootFolder);
createFolderRequest.Comment = Encoding.ASCII.GetBytes(this.RootFolder);
createFolderResponse = this.Adapter.CreateFolder(createFolderRequest, this.inboxFolderHandle, ref this.responseHandles);
Site.Assert.AreEqual <uint>(0, createFolderResponse.ReturnValue, "Creating Folder should succeed.");
this.rootFolderHandle = this.responseHandles[0][createFolderResponse.OutputHandleIndex];
this.rootFolderId = createFolderResponse.FolderId;
this.isRootFolderCreated = true;
#endregion
}
/// <summary>
/// Hard delete messages and subfolders under the specified folder.
/// </summary>
/// <param name="folderIndex">The id of folder in which subfolders and messages should be deleted</param>
protected void HardDeleteMessagesAndSubfolders(FolderIds folderIndex)
{
#region Client connects with Server
this.pcbOut = ConstValues.ValidpcbOut;
this.pcbAuxOut = ConstValues.ValidpcbAuxOut;
this.returnValue = this.oxcrpcAdapter.EcDoConnectEx(
ref this.pcxh,
TestSuiteBase.UlIcxrLinkForNoSessionLink,
ref this.pulTimeStamp,
null,
this.userDN,
ref this.pcbAuxOut,
this.rgwClientVersion,
out this.rgwBestVersion,
out this.picxr);
Site.Assert.AreEqual <uint>(0, this.returnValue, "EcDoConnectEx should succeed. This call is the precondition for EcDoRpcExt2. '0' is expected to be returned. The returned value is {0}.", this.returnValue);
#endregion
#region Logon to mailbox
this.rgbIn = AdapterHelper.ComposeRgbIn(ROPCommandType.RopLogon, this.unusedInfo, this.userPrivilege);
this.pcbOut = ConstValues.ValidpcbOut;
this.pcbAuxOut = ConstValues.ValidpcbAuxOut;
this.returnValue = this.oxcrpcAdapter.EcDoRpcExt2(
ref this.pcxh,
PulFlags.NoCompression | PulFlags.NoXorMagic,
this.rgbIn,
ref this.pcbOut,
null,
ref this.pcbAuxOut,
out this.response,
ref this.responseSOHTable);
Site.Assert.AreEqual <uint>(0, this.returnValue, "RopLogon should succeed and '0' is expected to be returned. The returned value is {0}.", this.returnValue);
RopLogonResponse logonResponse = (RopLogonResponse)this.response;
uint logonHandle = this.responseSOHTable[TestSuiteBase.FIRST][logonResponse.OutputHandleIndex];
#endregion
#region OpenFolder
this.rgbIn = AdapterHelper.ComposeRgbIn(ROPCommandType.RopOpenFolder, logonHandle, logonResponse.FolderIds[(int)folderIndex]);
this.pcbOut = ConstValues.ValidpcbOut;
this.pcbAuxOut = ConstValues.ValidpcbAuxOut;
this.responseSOHTable = new List <List <uint> >();
uint payloadCount = 0;
this.returnValue = this.oxcrpcAdapter.EcDoRpcExt2(
ref this.pcxh,
PulFlags.NoXorMagic,
this.rgbIn,
ref this.rgbOut,
ref this.pcbOut,
null,
ref this.pcbAuxOut,
out this.response,
ref this.responseSOHTable,
out payloadCount,
ref this.rgbAuxOut);
Site.Assert.AreEqual <uint>(0, this.returnValue, "RopOpenFolder should succeed and '0' is expected to be returned. The returned value is {0}.", this.returnValue);
RopOpenFolderResponse openFolderResponse = (RopOpenFolderResponse)this.response;
this.objHandle = this.responseSOHTable[TestSuiteBase.FIRST][openFolderResponse.OutputHandleIndex];
#endregion
#region HardDeleteFoldersAndMessages
this.rgbIn = AdapterHelper.ComposeRgbIn(ROPCommandType.RopHardDeleteMessagesAndSubfolders, this.objHandle, 0);
this.pcbOut = ConstValues.ValidpcbOut;
this.pcbAuxOut = ConstValues.ValidpcbAuxOut;
this.responseSOHTable = new List <List <uint> >();
payloadCount = 0;
this.returnValue = this.oxcrpcAdapter.EcDoRpcExt2(
ref this.pcxh,
PulFlags.NoXorMagic,
this.rgbIn,
ref this.rgbOut,
ref this.pcbOut,
null,
ref this.pcbAuxOut,
out this.response,
ref this.responseSOHTable,
out payloadCount,
ref this.rgbAuxOut);
// The returned value 1125 means ecNoDelSubmitMsg, that is, deleting a message that has been submitted for sending is not permitted.
bool retValue = (this.returnValue == 0) || (this.returnValue == 1125);
Site.Assert.AreEqual <bool>(true, retValue, "The returned status is {0}. TRUE means that RopHardDeleteMessagesAndSubfolders succeed, and FALSE means that RopHardDeleteMessagesAndSubfolders failed.", retValue);
#endregion
#region Client disconnects with Server
this.returnValue = this.oxcrpcAdapter.EcDoDisconnect(ref this.pcxh);
Site.Assert.AreEqual <uint>(0, this.returnValue, "EcDoDisconnect should succeed and '0' is expected to be returned. The returned value is {0}.", this.returnValue);
#endregion
}
