smb-msg 0.11.2

SMB Messages and structures for `smb-rs`
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

//! OpLock messages (requests, responses, notifications)

use crate::FileId;
use binrw::prelude::*;
use modular_bitfield::prelude::*;
use smb_dtyp::Guid;
use smb_msg_derive::*;

/// Oplock Break Notification/Acknowledgment/Response message.
///
/// Used for oplock break notification (server to client), acknowledgment (client to server),
/// and response (server to client) operations. The structure is identical for all three operations.
///
/// Reference: MS-SMB2 2.2.23.1, 2.2.24.1, 2.2.25.1
#[smb_request_response(size = 12)]
pub struct OplockBreakMsg {
    /// The oplock level. For notifications, this is the maximum level the server will accept.
    /// For acknowledgments, this is the lowered level the client accepts.
    /// For responses, this is the granted level.
    oplock_level: u8,
    reserved: u8,
    reserved: u32,
    /// The file identifier on which the oplock break occurred.
    file_id: FileId,
}

/// Lease Break Notification message.
///
/// Sent by the server when the underlying object store indicates that a lease is being broken,
/// representing a change in the lease state. Not valid for SMB 2.0.2 dialect.
///
/// Reference: MS-SMB2 2.2.23.2
#[smb_response(size = 44)]
pub struct LeaseBreakNotify {
    /// A 16-bit unsigned integer indicating a lease state change by the server.
    /// Only valid for SMB 3.x dialect family. For SMB 2.1, this field is reserved.
    new_epoch: u16,
    /// Flag indicating whether a Lease Break Acknowledgment is required.
    ack_required: u32,
    /// The client-generated key that identifies the owner of the lease.
    lease_key: Guid,
    /// The current lease state of the open.
    current_lease_state: LeaseState,
    /// The new lease state for the open.
    new_lease_state: LeaseState,
    #[bw(calc = 0)]
    #[br(assert(break_reason == 0))]
    #[br(temp)]
    break_reason: u32,
    #[bw(calc = 0)]
    #[br(assert(access_mask_hint == 0))]
    #[br(temp)]
    access_mask_hint: u32,
    #[bw(calc = 0)]
    #[br(assert(share_mask_hint == 0))]
    #[br(temp)]
    share_mask_hint: u32,
}

/// Oplock level values used in oplock break operations.
///
/// Reference: MS-SMB2 2.2.23.1
#[smb_message_binrw]
#[brw(repr(u8))]
pub enum OplockLevel {
    /// No oplock is available.
    None = 0,
    /// A level II oplock is available.
    II = 1,
    /// Exclusive oplock is available.
    Exclusive = 2,
}

/// Lease state bitfield representing different types of caching permissions.
///
/// Reference: MS-SMB2 2.2.23.2
#[smb_dtyp::mbitfield]
pub struct LeaseState {
    /// A read caching lease is granted/requested.
    pub read_caching: bool,
    /// A handle caching lease is granted/requested.
    pub handle_caching: bool,
    /// A write caching lease is granted/requested.
    pub write_caching: bool,
    #[skip]
    __: B29,
}

// Type aliases for oplock break operations that use the same structure.
// Reference: MS-SMB2 2.2.23.1, 2.2.24.1, 2.2.25.1

/// Oplock Break Notification - sent by server when an oplock is being broken.
pub type OplockBreakNotify = OplockBreakMsg;

/// Oplock Break Acknowledgment - sent by client in response to oplock break notification.
pub type OplockBreakAck = OplockBreakMsg;

/// Oplock Break Response - sent by server in response to oplock break acknowledgment.
pub type OplockBreakResponse = OplockBreakMsg;

/// Lease Break Acknowledgment/Response message.
///
/// Used for lease break acknowledgment (client to server) and response (server to client).
/// The structure is identical for both operations. Not valid for SMB 2.0.2 dialect.
///
/// Reference: MS-SMB2 2.2.24.2, 2.2.25.2
#[smb_request_response(size = 36)]
pub struct LeaseBreakAckResponse {
    reserved: u16,
    /// Flags (reserved)
    reserved: u32,

    /// The client-generated key that identifies the owner of the lease.
    lease_key: Guid,
    /// The lease state. For acknowledgments, this must be a subset of the lease state
    /// granted by the server. For responses, this is the requested lease state.
    lease_state: LeaseState,

    /// Lease duration (reserved)
    reserved: u64,
}

// Type aliases for lease break operations that use the same structure.
// Reference: MS-SMB2 2.2.24.2, 2.2.25.2

/// Lease Break Acknowledgment - sent by client in response to lease break notification.
pub type LeaseBreakAck = LeaseBreakAckResponse;

/// Lease Break Response - sent by server in response to lease break acknowledgment.
pub type LeaseBreakResponse = LeaseBreakAckResponse;

#[cfg(test)]
mod tests {
    use crate::*;

    use super::*;

    test_binrw_response! {
        struct LeaseBreakNotify {
            new_epoch: 2,
            ack_required: 1,
            lease_key: "70c8619e-165d-315e-d492-a01b0cbb3af2".parse().unwrap(),
            current_lease_state: LeaseState::new()
                .with_read_caching(true)
                .with_handle_caching(true),
            new_lease_state: LeaseState::new(),
        } => "2c000200010000009e61c8705d165e31d492a01b0cbb3af20300000000000000000000000000000000000000"
    }

    test_binrw_response! {
        struct LeaseBreakAck {
            lease_key: "70c8619e-165d-315e-d492-a01b0cbb3af2".parse().unwrap(),
            lease_state: LeaseState::new(),
        } => "24000000000000009e61c8705d165e31d492a01b0cbb3af2000000000000000000000000"
    }

    test_binrw_response! {
        struct LeaseBreakAckResponse {
            lease_key: "70c8619e-165d-315e-d492-a01b0cbb3af2".parse().unwrap(),
            lease_state: LeaseState::new(),
        } => "24000000000000009e61c8705d165e31d492a01b0cbb3af2000000000000000000000000"
    }
}