public static void OplockBreakResponse(ModelSmb2Status status, OPLOCK_BREAK_Response_OplockLevel_Values oplockLevel, OplockLevel_Values oplockLevelOnOpen)
        {
            Condition.IsTrue(State == ModelState.Connected);
            Condition.IsNotNull(Request);

            ModelOplockBreakAcknowledgementRequest oplockBreakAckRequest = ModelHelper.RetrieveOutstandingRequest<ModelOplockBreakAcknowledgementRequest>(ref Request);

            ModelHelper.Log(LogType.Requirement,
                "3.3.5.22.1   Processing an Oplock Acknowledgment");

            if (!oplockBreakAckRequest.VolatilePortionFound
                || !oplockBreakAckRequest.PersistentMatchesDurableFileId)
            {
                ModelHelper.Log(LogType.Requirement,
                    "Next, the server MUST locate the open on which the client is acknowledging an oplock break by performing a lookup in Session.OpenTable " +
                    "using FileId.Volatile of the request as the lookup key. If no open is found, or if Open.DurableFileId is not equal to FileId.Persistent, " +
                    "the server MUST fail the request with STATUS_FILE_CLOSED. ");
                ModelHelper.Log(LogType.TestTag, TestTag.InvalidIdentifier);

                if (!oplockBreakAckRequest.VolatilePortionFound)
                {
                    ModelHelper.Log(LogType.TestInfo, "Open is not found.");
                }
                if (!oplockBreakAckRequest.PersistentMatchesDurableFileId)
                {
                    ModelHelper.Log(LogType.TestInfo, "Open.DurableFileId is not equal to FileId.Persistent.");
                }
                Condition.IsTrue(status == ModelSmb2Status.STATUS_FILE_CLOSED);
                return;
            }

            // We need this to avoid Open.OplockLevel being symbolic which will result case exploration failure
            Condition.IsTrue(Open.OplockLevel == oplockLevelOnOpen);
            Condition.IsTrue(oplockLevelOnOpen == OplockLevel_Values.OPLOCK_LEVEL_NONE
                || oplockLevelOnOpen == OplockLevel_Values.OPLOCK_LEVEL_II
                || oplockLevelOnOpen == OplockLevel_Values.OPLOCK_LEVEL_BATCH);

            if (oplockBreakAckRequest.OplockLevel == OplockLevel_Values.OPLOCK_LEVEL_LEASE)
            {
                ModelHelper.Log(LogType.Requirement,
                    "If the OplockLevel in the acknowledgment is SMB2_OPLOCK_LEVEL_LEASE, the server MUST do the following:");
                ModelHelper.Log(LogType.TestInfo, "Open.OplockState is {0}.", Open.OplockState);

                if (Open.OplockState != OplockState.Breaking)
                {
                    ModelHelper.Log(LogType.Requirement,
                        "If Open.OplockState is not Breaking, stop processing the acknowledgment, " +
                        "and send an error response with STATUS_INVALID_PARAMETER.");
                    ModelHelper.Log(LogType.TestTag, TestTag.Compatibility);
                    Condition.IsTrue(status == ModelSmb2Status.STATUS_INVALID_PARAMETER);
                    return;
                }
                else
                {
                    ModelHelper.Log(LogType.Requirement,
                        "If Open.OplockState is Breaking, complete the oplock break request received from the object store as described in section 3.3.4.6, " +
                        "with a new level SMB2_OPLOCK_LEVEL_NONE in an implementation-specific manner,<350> and set Open.OplockLevel to SMB2_OPLOCK_LEVEL_NONE, " +
                        "and Open.OplockState to None.");
                    ModelHelper.Log(LogType.TestInfo, "Open.OplockLevel is set to SMB2_OPLOCK_LEVEL_NONE, and Open.OplockState is set to None");
                    Open.OplockLevel = OplockLevel_Values.OPLOCK_LEVEL_NONE;
                    Open.OplockState = OplockState.None;

                    // Do not assert implementation-specific manner
                    return;
                }
            }

            if ((Open.OplockLevel == OplockLevel_Values.OPLOCK_LEVEL_EXCLUSIVE
                || Open.OplockLevel == OplockLevel_Values.OPLOCK_LEVEL_BATCH)
                && (oplockBreakAckRequest.OplockLevel != OplockLevel_Values.OPLOCK_LEVEL_II && oplockBreakAckRequest.OplockLevel != OplockLevel_Values.OPLOCK_LEVEL_NONE))
            {
                ModelHelper.Log(LogType.Requirement,
                    "If Open.OplockLevel is SMB2_OPLOCK_LEVEL_EXCLUSIVE or SMB2_OPLOCK_LEVEL_BATCH, " +
                    "and if OplockLevel is not SMB2_OPLOCK_LEVEL_II or SMB2_OPLOCK_LEVEL_NONE, the server MUST do the following:");
                ModelHelper.Log(LogType.TestInfo, "Open.OplockState is {0}.", Open.OplockState);

                if (Open.OplockState != OplockState.Breaking)
                {
                    ModelHelper.Log(LogType.Requirement,
                        "If Open.OplockState is not Breaking, stop processing the acknowledgment, " +
                        "and send an error response with STATUS_INVALID_OPLOCK_PROTOCOL.");
                    ModelHelper.Log(LogType.TestTag, TestTag.Compatibility);
                    Condition.IsTrue(status == ModelSmb2Status.STATUS_INVALID_OPLOCK_PROTOCOL);
                    return;
                }
                else
                {
                    ModelHelper.Log(LogType.Requirement,
                        "If Open.OplockState is Breaking, complete the oplock break request received from the object store, " +
                        "as described in section 3.3.4.6, with a new level SMB2_OPLOCK_LEVEL_NONE in an implementation-specific manner," +
                        "<351> and set Open.OplockLevel to SMB2_OPLOCK_LEVEL_NONE and Open.OplockState to None.");
                    ModelHelper.Log(LogType.TestInfo, "Open.OplockLevel is set to SMB2_OPLOCK_LEVEL_NONE, and Open.OplockState is set to None");
                    Open.OplockLevel = OplockLevel_Values.OPLOCK_LEVEL_NONE;
                    Open.OplockState = OplockState.None;

                    // Do not assert implementation-specific manner
                    return;
                }
            }

            if (Open.OplockLevel == OplockLevel_Values.OPLOCK_LEVEL_II
                && oplockBreakAckRequest.OplockLevel != OplockLevel_Values.OPLOCK_LEVEL_NONE)
            {
                ModelHelper.Log(LogType.Requirement,
                    "If Open.OplockLevel is SMB2_OPLOCK_LEVEL_II, and if OplockLevel is not SMB2_OPLOCK_LEVEL_NONE, " +
                    "the server MUST do the following:");
                ModelHelper.Log(LogType.TestInfo, "Open.OplockState is {0}.", Open.OplockState);

                if (Open.OplockState != OplockState.Breaking)
                {
                    ModelHelper.Log(LogType.Requirement,
                        "If Open.OplockState is not Breaking, stop processing the acknowledgment, and send an error response with STATUS_INVALID_OPLOCK_PROTOCOL.");
                    ModelHelper.Log(LogType.TestTag, TestTag.Compatibility);
                    Condition.IsTrue(status == ModelSmb2Status.STATUS_INVALID_OPLOCK_PROTOCOL);
                    return;
                }
                else
                {
                    ModelHelper.Log(LogType.Requirement,
                        "If Open.OplockState is Breaking, complete the oplock break request received from the object store, " +
                        "as described in section 3.3.4.6, with a new level SMB2_OPLOCK_LEVEL_NONE in an implementation-specific manner," +
                        "<352> and set Open.OplockLevel to SMB2_OPLOCK_LEVEL_NONE and Open.OplockState to None.");
                    ModelHelper.Log(LogType.TestInfo, "Open.OplockLevel is set to SMB2_OPLOCK_LEVEL_NONE, and Open.OplockState is set to None");
                    Open.OplockLevel = OplockLevel_Values.OPLOCK_LEVEL_NONE;
                    Open.OplockState = OplockState.None;

                    // Do not assert implementation-specific manner
                    return;
                }
            }

            if (oplockBreakAckRequest.OplockLevel == OplockLevel_Values.OPLOCK_LEVEL_II
                || oplockBreakAckRequest.OplockLevel == OplockLevel_Values.OPLOCK_LEVEL_NONE)
            {
                ModelHelper.Log(LogType.Requirement,
                    "If OplockLevel is SMB2_OPLOCK_LEVEL_II or SMB2_OPLOCK_LEVEL_NONE, the server MUST do the following:");
                ModelHelper.Log(LogType.TestInfo, "Open.OplockState is {0}.", Open.OplockState);

                if (Open.OplockState != OplockState.Breaking)
                {
                    ModelHelper.Log(LogType.Requirement,
                        "If Open.OplockState is not Breaking, stop processing the acknowledgment, " +
                        "and send an error response with STATUS_INVALID_DEVICE_STATE.");
                    ModelHelper.Log(LogType.TestTag, TestTag.Compatibility);
                    Condition.IsTrue(status == ModelSmb2Status.STATUS_INVALID_DEVICE_STATE);
                    return;
                }
                else
                {
                    ModelHelper.Log(LogType.Requirement,
                        "If Open.OplockState is Breaking, " +
                        "complete the oplock break request received from the object store as described in section 3.3.4.6, " +
                        "with a new level received in OplockLevel in an implementation-specific manner.<353>");

                    if (status != ModelSmb2Status.STATUS_SUCCESS)
                    {
                        ModelHelper.Log(LogType.Requirement,
                            "If the object store indicates an error, set the Open.OplockLevel to SMB2_OPLOCK_LEVEL_NONE, " +
                            "the Open.OplockState to None, and send the error response with the error code received.");
                        ModelHelper.Log(LogType.TestInfo, "Open.OplockLevel is set to SMB2_OPLOCK_LEVEL_NONE, and Open.OplockState is set to None");
                        Open.OplockLevel = OplockLevel_Values.OPLOCK_LEVEL_NONE;
                        Open.OplockState = OplockState.None;
                        return;
                    }
                    else
                    {
                        ModelHelper.Log(LogType.Requirement,
                            "If the object store indicates success, update Open.OplockLevel and Open.OplockState as follows:");
                        if (oplockBreakAckRequest.OplockLevel == OplockLevel_Values.OPLOCK_LEVEL_II)
                        {
                            ModelHelper.Log(LogType.Requirement,
                                "If OplockLevel is SMB2_OPLOCK_LEVEL_II, " +
                                "set Open.OplockLevel to SMB2_OPLOCK_LEVEL_II and Open.OplockState to Held.");
                            ModelHelper.Log(LogType.TestInfo, "Open.OplockLevel is set to OPLOCK_LEVEL_II, and Open.OplockState is set to None");
                            Open.OplockLevel = OplockLevel_Values.OPLOCK_LEVEL_II;
                            Open.OplockState = OplockState.Held;
                        }
                        if (oplockBreakAckRequest.OplockLevel == OplockLevel_Values.OPLOCK_LEVEL_NONE)
                        {
                            ModelHelper.Log(LogType.Requirement,
                                "If OplockLevel is SMB2_OPLOCK_LEVEL_NONE, " +
                                "set Open.OplockLevel to SMB2_OPLOCK_LEVEL_NONE and the Open.OplockState to None.");
                            ModelHelper.Log(LogType.TestInfo, "Open.OplockLevel is set to SMB2_OPLOCK_LEVEL_NONE, and Open.OplockState is set to None");
                            Open.OplockLevel = OplockLevel_Values.OPLOCK_LEVEL_NONE;
                            Open.OplockState = OplockState.None;
                        }
                    }
                }
            }

            ModelHelper.Log(LogType.Requirement,
                "The server then MUST construct an oplock break response using the syntax specified in section 2.2.25 with the following value:");
            ModelHelper.Log(LogType.Requirement,
                "OplockLevel MUST be set to Open.OplockLevel.");
            ModelHelper.Log(LogType.TestInfo,
                "Open.OplockLevel is {0}.", Open.OplockLevel);

            Condition.IsTrue(Open.OplockLevel == (OplockLevel_Values)oplockLevel);

            Condition.IsTrue(status == ModelSmb2Status.STATUS_SUCCESS);
        }
Ejemplo n.º 2
0
        public static void OplockBreakResponse(ModelSmb2Status status, OPLOCK_BREAK_Response_OplockLevel_Values oplockLevel, OplockLevel_Values oplockLevelOnOpen)
        {
            Condition.IsTrue(State == ModelState.Connected);
            Condition.IsNotNull(Request);

            ModelOplockBreakAcknowledgementRequest oplockBreakAckRequest = ModelHelper.RetrieveOutstandingRequest <ModelOplockBreakAcknowledgementRequest>(ref Request);

            ModelHelper.Log(LogType.Requirement,
                            "3.3.5.22.1   Processing an Oplock Acknowledgment");

            if (!oplockBreakAckRequest.VolatilePortionFound ||
                !oplockBreakAckRequest.PersistentMatchesDurableFileId)
            {
                ModelHelper.Log(LogType.Requirement,
                                "Next, the server MUST locate the open on which the client is acknowledging an oplock break by performing a lookup in Session.OpenTable " +
                                "using FileId.Volatile of the request as the lookup key. If no open is found, or if Open.DurableFileId is not equal to FileId.Persistent, " +
                                "the server MUST fail the request with STATUS_FILE_CLOSED. ");
                ModelHelper.Log(LogType.TestTag, TestTag.InvalidIdentifier);

                if (!oplockBreakAckRequest.VolatilePortionFound)
                {
                    ModelHelper.Log(LogType.TestInfo, "Open is not found.");
                }
                if (!oplockBreakAckRequest.PersistentMatchesDurableFileId)
                {
                    ModelHelper.Log(LogType.TestInfo, "Open.DurableFileId is not equal to FileId.Persistent.");
                }
                Condition.IsTrue(status == ModelSmb2Status.STATUS_FILE_CLOSED);
                return;
            }

            // We need this to avoid Open.OplockLevel being symbolic which will result case exploration failure
            Condition.IsTrue(Open.OplockLevel == oplockLevelOnOpen);
            Condition.IsTrue(oplockLevelOnOpen == OplockLevel_Values.OPLOCK_LEVEL_NONE ||
                             oplockLevelOnOpen == OplockLevel_Values.OPLOCK_LEVEL_II ||
                             oplockLevelOnOpen == OplockLevel_Values.OPLOCK_LEVEL_BATCH);

            if (oplockBreakAckRequest.OplockLevel == OplockLevel_Values.OPLOCK_LEVEL_LEASE)
            {
                ModelHelper.Log(LogType.Requirement,
                                "If the OplockLevel in the acknowledgment is SMB2_OPLOCK_LEVEL_LEASE, the server MUST do the following:");
                ModelHelper.Log(LogType.TestInfo, "Open.OplockState is {0}.", Open.OplockState);

                if (Open.OplockState != OplockState.Breaking)
                {
                    ModelHelper.Log(LogType.Requirement,
                                    "If Open.OplockState is not Breaking, stop processing the acknowledgment, " +
                                    "and send an error response with STATUS_INVALID_PARAMETER.");
                    ModelHelper.Log(LogType.TestTag, TestTag.Compatibility);
                    Condition.IsTrue(status == ModelSmb2Status.STATUS_INVALID_PARAMETER);
                    return;
                }
                else
                {
                    ModelHelper.Log(LogType.Requirement,
                                    "If Open.OplockState is Breaking, complete the oplock break request received from the object store as described in section 3.3.4.6, " +
                                    "with a new level SMB2_OPLOCK_LEVEL_NONE in an implementation-specific manner,<350> and set Open.OplockLevel to SMB2_OPLOCK_LEVEL_NONE, " +
                                    "and Open.OplockState to None.");
                    ModelHelper.Log(LogType.TestInfo, "Open.OplockLevel is set to SMB2_OPLOCK_LEVEL_NONE, and Open.OplockState is set to None");
                    Open.OplockLevel = OplockLevel_Values.OPLOCK_LEVEL_NONE;
                    Open.OplockState = OplockState.None;

                    // Do not assert implementation-specific manner
                    return;
                }
            }

            if ((Open.OplockLevel == OplockLevel_Values.OPLOCK_LEVEL_EXCLUSIVE ||
                 Open.OplockLevel == OplockLevel_Values.OPLOCK_LEVEL_BATCH) &&
                (oplockBreakAckRequest.OplockLevel != OplockLevel_Values.OPLOCK_LEVEL_II && oplockBreakAckRequest.OplockLevel != OplockLevel_Values.OPLOCK_LEVEL_NONE))
            {
                ModelHelper.Log(LogType.Requirement,
                                "If Open.OplockLevel is SMB2_OPLOCK_LEVEL_EXCLUSIVE or SMB2_OPLOCK_LEVEL_BATCH, " +
                                "and if OplockLevel is not SMB2_OPLOCK_LEVEL_II or SMB2_OPLOCK_LEVEL_NONE, the server MUST do the following:");
                ModelHelper.Log(LogType.TestInfo, "Open.OplockState is {0}.", Open.OplockState);

                if (Open.OplockState != OplockState.Breaking)
                {
                    ModelHelper.Log(LogType.Requirement,
                                    "If Open.OplockState is not Breaking, stop processing the acknowledgment, " +
                                    "and send an error response with STATUS_INVALID_OPLOCK_PROTOCOL.");
                    ModelHelper.Log(LogType.TestTag, TestTag.Compatibility);
                    Condition.IsTrue(status == ModelSmb2Status.STATUS_INVALID_OPLOCK_PROTOCOL);
                    return;
                }
                else
                {
                    ModelHelper.Log(LogType.Requirement,
                                    "If Open.OplockState is Breaking, complete the oplock break request received from the object store, " +
                                    "as described in section 3.3.4.6, with a new level SMB2_OPLOCK_LEVEL_NONE in an implementation-specific manner," +
                                    "<351> and set Open.OplockLevel to SMB2_OPLOCK_LEVEL_NONE and Open.OplockState to None.");
                    ModelHelper.Log(LogType.TestInfo, "Open.OplockLevel is set to SMB2_OPLOCK_LEVEL_NONE, and Open.OplockState is set to None");
                    Open.OplockLevel = OplockLevel_Values.OPLOCK_LEVEL_NONE;
                    Open.OplockState = OplockState.None;

                    // Do not assert implementation-specific manner
                    return;
                }
            }

            if (Open.OplockLevel == OplockLevel_Values.OPLOCK_LEVEL_II &&
                oplockBreakAckRequest.OplockLevel != OplockLevel_Values.OPLOCK_LEVEL_NONE)
            {
                ModelHelper.Log(LogType.Requirement,
                                "If Open.OplockLevel is SMB2_OPLOCK_LEVEL_II, and if OplockLevel is not SMB2_OPLOCK_LEVEL_NONE, " +
                                "the server MUST do the following:");
                ModelHelper.Log(LogType.TestInfo, "Open.OplockState is {0}.", Open.OplockState);

                if (Open.OplockState != OplockState.Breaking)
                {
                    ModelHelper.Log(LogType.Requirement,
                                    "If Open.OplockState is not Breaking, stop processing the acknowledgment, and send an error response with STATUS_INVALID_OPLOCK_PROTOCOL.");
                    ModelHelper.Log(LogType.TestTag, TestTag.Compatibility);
                    Condition.IsTrue(status == ModelSmb2Status.STATUS_INVALID_OPLOCK_PROTOCOL);
                    return;
                }
                else
                {
                    ModelHelper.Log(LogType.Requirement,
                                    "If Open.OplockState is Breaking, complete the oplock break request received from the object store, " +
                                    "as described in section 3.3.4.6, with a new level SMB2_OPLOCK_LEVEL_NONE in an implementation-specific manner," +
                                    "<352> and set Open.OplockLevel to SMB2_OPLOCK_LEVEL_NONE and Open.OplockState to None.");
                    ModelHelper.Log(LogType.TestInfo, "Open.OplockLevel is set to SMB2_OPLOCK_LEVEL_NONE, and Open.OplockState is set to None");
                    Open.OplockLevel = OplockLevel_Values.OPLOCK_LEVEL_NONE;
                    Open.OplockState = OplockState.None;

                    // Do not assert implementation-specific manner
                    return;
                }
            }

            if (oplockBreakAckRequest.OplockLevel == OplockLevel_Values.OPLOCK_LEVEL_II ||
                oplockBreakAckRequest.OplockLevel == OplockLevel_Values.OPLOCK_LEVEL_NONE)
            {
                ModelHelper.Log(LogType.Requirement,
                                "If OplockLevel is SMB2_OPLOCK_LEVEL_II or SMB2_OPLOCK_LEVEL_NONE, the server MUST do the following:");
                ModelHelper.Log(LogType.TestInfo, "Open.OplockState is {0}.", Open.OplockState);

                if (Open.OplockState != OplockState.Breaking)
                {
                    ModelHelper.Log(LogType.Requirement,
                                    "If Open.OplockState is not Breaking, stop processing the acknowledgment, " +
                                    "and send an error response with STATUS_INVALID_DEVICE_STATE.");
                    ModelHelper.Log(LogType.TestTag, TestTag.Compatibility);
                    Condition.IsTrue(status == ModelSmb2Status.STATUS_INVALID_DEVICE_STATE);
                    return;
                }
                else
                {
                    ModelHelper.Log(LogType.Requirement,
                                    "If Open.OplockState is Breaking, " +
                                    "complete the oplock break request received from the object store as described in section 3.3.4.6, " +
                                    "with a new level received in OplockLevel in an implementation-specific manner.<353>");

                    if (status != ModelSmb2Status.STATUS_SUCCESS)
                    {
                        ModelHelper.Log(LogType.Requirement,
                                        "If the object store indicates an error, set the Open.OplockLevel to SMB2_OPLOCK_LEVEL_NONE, " +
                                        "the Open.OplockState to None, and send the error response with the error code received.");
                        ModelHelper.Log(LogType.TestInfo, "Open.OplockLevel is set to SMB2_OPLOCK_LEVEL_NONE, and Open.OplockState is set to None");
                        Open.OplockLevel = OplockLevel_Values.OPLOCK_LEVEL_NONE;
                        Open.OplockState = OplockState.None;
                        return;
                    }
                    else
                    {
                        ModelHelper.Log(LogType.Requirement,
                                        "If the object store indicates success, update Open.OplockLevel and Open.OplockState as follows:");
                        if (oplockBreakAckRequest.OplockLevel == OplockLevel_Values.OPLOCK_LEVEL_II)
                        {
                            ModelHelper.Log(LogType.Requirement,
                                            "If OplockLevel is SMB2_OPLOCK_LEVEL_II, " +
                                            "set Open.OplockLevel to SMB2_OPLOCK_LEVEL_II and Open.OplockState to Held.");
                            ModelHelper.Log(LogType.TestInfo, "Open.OplockLevel is set to OPLOCK_LEVEL_II, and Open.OplockState is set to None");
                            Open.OplockLevel = OplockLevel_Values.OPLOCK_LEVEL_II;
                            Open.OplockState = OplockState.Held;
                        }
                        if (oplockBreakAckRequest.OplockLevel == OplockLevel_Values.OPLOCK_LEVEL_NONE)
                        {
                            ModelHelper.Log(LogType.Requirement,
                                            "If OplockLevel is SMB2_OPLOCK_LEVEL_NONE, " +
                                            "set Open.OplockLevel to SMB2_OPLOCK_LEVEL_NONE and the Open.OplockState to None.");
                            ModelHelper.Log(LogType.TestInfo, "Open.OplockLevel is set to SMB2_OPLOCK_LEVEL_NONE, and Open.OplockState is set to None");
                            Open.OplockLevel = OplockLevel_Values.OPLOCK_LEVEL_NONE;
                            Open.OplockState = OplockState.None;
                        }
                    }
                }
            }

            ModelHelper.Log(LogType.Requirement,
                            "The server then MUST construct an oplock break response using the syntax specified in section 2.2.25 with the following value:");
            ModelHelper.Log(LogType.Requirement,
                            "OplockLevel MUST be set to Open.OplockLevel.");
            ModelHelper.Log(LogType.TestInfo,
                            "Open.OplockLevel is {0}.", Open.OplockLevel);

            Condition.IsTrue(Open.OplockLevel == (OplockLevel_Values)oplockLevel);

            Condition.IsTrue(status == ModelSmb2Status.STATUS_SUCCESS);
        }
        public Smb2OpLockBreakResponsePacket CreateOpLockBreakResponse(
            Smb2Endpoint endpoint,
            ulong messageId,
            OPLOCK_BREAK_Response_OplockLevel_Values oplockLevel
            )
        {
            Smb2OpLockBreakResponsePacket packet = new Smb2OpLockBreakResponsePacket();

            SetHeader(packet, endpoint, messageId);

            Smb2OpLockBreakAckPacket oplockAck = context.FindRequestPacket(endpoint.EndpointId, messageId)
                as Smb2OpLockBreakAckPacket;
            packet.PayLoad.FileId = oplockAck.GetFileId();
            packet.PayLoad.OplockLevel = oplockLevel;
            packet.PayLoad.Reserved = OPLOCK_BREAK_Response_Reserved_Values.V1;
            packet.PayLoad.Reserved2 = OPLOCK_BREAK_Response_Reserved2_Values.V1;
            packet.PayLoad.StructureSize = OPLOCK_BREAK_Response_StructureSize_Values.V1;

            packet.Sign();

            return packet;
        }