named!(pub parse_message<String>,
do_parse!(
- len: map_res!(
- map_res!(take_until_s!(":"), std::str::from_utf8), parse_len) >>
- sep: take!(1) >>
- msg: take_str!(len) >>
+ len: map_res!(
+ map_res!(take_until_s!(":"), std::str::from_utf8), parse_len) >>
+ _sep: take!(1) >>
+ msg: take_str!(len) >>
(
msg.to_string()
)
named!(pub parse_clientid_option<DHCPOption>,
do_parse!(
- code: be_u8 >>
- len: be_u8 >>
- htype: be_u8 >>
- data: take!(len - 1) >>
+ code: be_u8 >>
+ len: be_u8 >>
+ _htype: be_u8 >>
+ data: take!(len - 1) >>
(
DHCPOption{
code: code,
named!(pub parse_address_time_option<DHCPOption>,
do_parse!(
- code: be_u8 >>
- len: be_u8 >>
+ code: be_u8 >>
+ _len: be_u8 >>
seconds: be_u32 >>
(
DHCPOption{
handle: parse_nfs2_handle
>> name_len: be_u32
>> name_contents: take!(name_len)
- >> name_padding: rest
+ >> _name_padding: rest
>> (
Nfs2RequestLookup {
- handle:handle,
+ handle,
name_vec:name_contents.to_vec(),
}
))
do_parse!(
handle: parse_nfs2_handle
>> offset: be_u32
- >> count: be_u32
+ >> _count: be_u32
>> (
Nfs2RequestRead {
- handle:handle,
- offset:offset,
+ handle,
+ offset
}
))
);
>> data_contents: rest
>> (
NfsReplyRead {
- status:status,
+ status,
attr_follows:1,
- attr_blob:attr_blob,
+ attr_blob,
count:data_len,
eof:false,
- data_len:data_len,
+ data_len,
data:data_contents,
}
))
named!(pub parse_nfs2_attribs<Nfs2Attributes>,
do_parse!(
atype: be_u32
- >> blob1: take!(16)
+ >> _blob1: take!(16)
>> asize: be_u32
- >> blob2: take!(44)
+ >> _blob2: take!(44)
>> (
Nfs2Attributes {
- atype:atype,
- asize:asize,
+ atype,
+ asize
}
))
);
handle: parse_nfs3_handle
>> name_len: be_u32
>> name: take!(name_len)
- >> fill_bytes: rest
+ >> _fill_bytes: rest
>> (
Nfs3RequestRemove {
handle:handle,
dir_handle: parse_nfs3_handle
>> name_len: be_u32
>> name: take!(name_len)
- >> fill_bytes: cond!(name_len % 4 != 0, take!(4 - name_len % 4))
+ >> _fill_bytes: cond!(name_len % 4 != 0, take!(4 - name_len % 4))
>> (
Nfs3RequestRmdir {
handle:dir_handle,
dir_handle: parse_nfs3_handle
>> name_len: be_u32
>> name: take!(name_len)
- >> fill_bytes: cond!(name_len % 4 != 0, take!(4 - name_len % 4))
- >> attributes: rest
+ >> _fill_bytes: cond!(name_len % 4 != 0, take!(4 - name_len % 4))
+ >> _attributes: rest
>> (
Nfs3RequestMkdir {
handle:dir_handle,
from_handle: parse_nfs3_handle
>> from_name_len: be_u32
>> from_name: take!(from_name_len)
- >> from_fill_bytes: cond!(from_name_len % 4 != 0, take!(4 - from_name_len % 4))
+ >> _from_fill_bytes: cond!(from_name_len % 4 != 0, take!(4 - from_name_len % 4))
>> to_handle: parse_nfs3_handle
>> to_name_len: be_u32
>> to_name: take!(to_name_len)
- >> to_fill_bytes: rest
+ >> _to_fill_bytes: rest
>> (
Nfs3RequestRename {
- from_handle:from_handle,
+ from_handle,
from_name_vec:from_name.to_vec(),
- to_handle:to_handle,
+ to_handle,
to_name_vec:to_name.to_vec(),
}
))
named!(pub parse_nfs3_request_commit<Nfs3RequestCommit>,
do_parse!(
handle: parse_nfs3_handle
- >> offset: be_u64
- >> count: be_u32
+ >> _offset: be_u64
+ >> _count: be_u32
>> (
Nfs3RequestCommit {
- handle:handle,
+ handle
}
))
);
do_parse!(
handle: parse_nfs3_handle
>> offset: be_u64
- >> count: be_u32
+ >> _count: be_u32
>> (
Nfs3RequestRead {
- handle:handle,
- offset:offset,
+ handle,
+ offset
}
))
);
handle: parse_nfs3_handle
>> name_len: be_u32
>> name_contents: take!(name_len)
- >> name_padding: rest
+ >> _name_padding: rest
>> (
Nfs3RequestLookup {
- handle:handle,
+ handle,
name_vec:name_contents.to_vec(),
}
))
named!(pub parse_nfs3_response_readdirplus_entry<Nfs3ResponseReaddirplusEntryC>,
do_parse!(
- file_id: be_u64
+ _file_id: be_u64
>> name_len: be_u32
>> name_content: take!(name_len)
- >> fill_bytes: cond!(name_len % 4 != 0, take!(4 - name_len % 4))
- >> cookie: take!(8)
+ >> _fill_bytes: cond!(name_len % 4 != 0, take!(4 - name_len % 4))
+ >> _cookie: take!(8)
>> attr_value_follows: be_u32
- >> attr: cond!(attr_value_follows==1, take!(84))
+ >> _attr: cond!(attr_value_follows==1, take!(84))
>> handle_value_follows: be_u32
>> handle: cond!(handle_value_follows==1, parse_nfs3_handle)
>> (
Nfs3ResponseReaddirplusEntryC {
name_vec:name_content.to_vec(),
- handle:handle,
+ handle,
}
)
)
named!(pub parse_nfs3_response_readdirplus_entry_cond<Nfs3ResponseReaddirplusEntry>,
do_parse!(
- value_follows: be_u32
+ value_follows: be_u32
>> entry: cond!(value_follows==1, parse_nfs3_response_readdirplus_entry)
>> (
Nfs3ResponseReaddirplusEntry {
- entry:entry,
+ entry
}
))
);
do_parse!(
status: be_u32
>> dir_attr_follows: be_u32
- >> dir_attr: cond!(dir_attr_follows == 1, take!(84))
- >> verifier: take!(8)
+ >> _dir_attr: cond!(dir_attr_follows == 1, take!(84))
+ >> _verifier: take!(8)
>> data: rest
>> ( Nfs3ResponseReaddirplus {
- status:status,
- data:data,
+ status,
+ data
} ))
);
named!(nfs4_req_setclientid<Nfs4RequestContent>,
do_parse!(
- client_verifier: take!(8)
+ _client_verifier: take!(8)
>> client_id: nfs4_parse_nfsstring
- >> cb_program: be_u32
+ >> _cb_program: be_u32
>> r_netid: nfs4_parse_nfsstring
>> r_addr: nfs4_parse_nfsstring
- >> cb_id: be_u32
+ >> _cb_id: be_u32
>> (Nfs4RequestContent::SetClientId(Nfs4RequestSetClientId {
- client_id: client_id,
- r_netid: r_netid,
- r_addr: r_addr,
+ client_id,
+ r_netid,
+ r_addr
}))
));
named!(nfs4_req_setclientid_confirm<Nfs4RequestContent>,
do_parse!(
- client_id: take!(8)
- >> verifier: take!(8)
+ _client_id: take!(8)
+ >> _verifier: take!(8)
>> (Nfs4RequestContent::SetClientIdConfirm)
));
ftype4: be_u32
>> link_content: cond!(ftype4 == 5, nfs4_parse_nfsstring)
>> filename: nfs4_parse_nfsstring
- >> attrs: nfs4_parse_attrs
+ >> _attrs: nfs4_parse_attrs
>> ( Nfs4RequestContent::Create(Nfs4RequestCreate {
ftype4: ftype4,
filename: filename,
named!(nfs4_req_open<Nfs4RequestContent>,
do_parse!(
- seqid: be_u32
- >> share_access: be_u32
- >> share_deny: be_u32
- >> client_id: be_u64
+ _seqid: be_u32
+ >> _share_access: be_u32
+ >> _share_deny: be_u32
+ >> _client_id: be_u64
>> owner_len: be_u32
>> cond!(owner_len > 0, take!(owner_len))
>> open_type: be_u32
>> open_data: cond!(open_type == 1, nfs4_req_open_type)
- >> claim_type: be_u32
+ >> _claim_type: be_u32
>> filename: nfs4_parse_nfsstring
>> ( Nfs4RequestContent::Open(Nfs4RequestOpen {
- open_type: open_type,
- filename: filename,
- open_data: open_data,
+ open_type,
+ filename,
+ open_data
})
))
);
named!(nfs4_req_readdir<Nfs4RequestContent>,
do_parse!(
- cookie: be_u64
- >> cookie_verf: be_u64
- >> dir_cnt: be_u32
- >> max_cnt: be_u32
- >> attr: nfs4_parse_attrbits
+ _cookie: be_u64
+ >> _cookie_verf: be_u64
+ >> _dir_cnt: be_u32
+ >> _max_cnt: be_u32
+ >> _attr: nfs4_parse_attrbits
>> ( Nfs4RequestContent::ReadDir )
)
);
oldname: nfs4_parse_nfsstring
>> newname: nfs4_parse_nfsstring
>> ( Nfs4RequestContent::Rename(Nfs4RequestRename {
- oldname: oldname,
- newname: newname,
+ oldname,
+ newname
})
))
);
do_parse!(
filename: nfs4_parse_nfsstring
>> ( Nfs4RequestContent::Lookup(Nfs4RequestLookup {
- filename: filename,
+ filename
})
))
);
named!(nfs4_req_setattr<Nfs4RequestContent>,
do_parse!(
stateid: nfs4_parse_stateid
- >> attrs: nfs4_parse_attrs
+ >> _attrs: nfs4_parse_attrs
>> (Nfs4RequestContent::SetAttr(Nfs4RequestSetAttr {
- stateid: stateid,
+ stateid
}))
));
named!(nfs4_req_close<Nfs4RequestContent>,
do_parse!(
- seqid: be_u32
+ _seqid: be_u32
>> stateid: nfs4_parse_stateid
>> ( Nfs4RequestContent::Close(stateid) )
));
named!(nfs4_req_open_confirm<Nfs4RequestContent>,
do_parse!(
stateid: nfs4_parse_stateid
- >> seqid: be_u32
+ >> _seqid: be_u32
>> ( Nfs4RequestContent::OpenConfirm(Nfs4RequestOpenConfirm {
- stateid: stateid,
+ stateid
})
))
);
named!(nfs4_req_commit<Nfs4RequestContent>,
do_parse!(
- offset: be_u64
- >> count: be_u32
+ _offset: be_u64
+ >> _count: be_u32
>> ( Nfs4RequestContent::Commit )
)
);
named!(nfs4_req_exchangeid<Nfs4RequestContent>,
do_parse!(
- verifier: take!(8)
+ _verifier: take!(8)
>> eia_clientstring: nfs4_parse_nfsstring
- >> eia_clientflags: be_u32
- >> eia_state_protect: be_u32
- >> eia_client_impl_id: be_u32
+ >> _eia_clientflags: be_u32
+ >> _eia_state_protect: be_u32
+ >> _eia_client_impl_id: be_u32
>> nii_domain: nfs4_parse_nfsstring
>> nii_name: nfs4_parse_nfsstring
- >> nii_data_sec: be_u64
- >> nii_data_nsec: be_u32
+ >> _nii_data_sec: be_u64
+ >> _nii_data_nsec: be_u32
>> (Nfs4RequestContent::ExchangeId(
Nfs4RequestExchangeId {
client_string: eia_clientstring,
- nii_domain: nii_domain,
- nii_name: nii_name,
+ nii_domain,
+ nii_name
}
))
));
named!(nfs4_req_sequence<Nfs4RequestContent>,
do_parse!(
ssn_id: take!(16)
- >> seq_id: be_u32
- >> slot_id: be_u32
- >> high_slot_id: be_u32
- >> cache_this: be_u32
+ >> _seq_id: be_u32
+ >> _slot_id: be_u32
+ >> _high_slot_id: be_u32
+ >> _cache_this: be_u32
>> (Nfs4RequestContent::Sequence(
Nfs4RequestSequence {
- ssn_id: ssn_id,
+ ssn_id
}
))
));
named!(pub parse_nfs4_request_compound<Nfs4RequestCompoundRecord>,
do_parse!(
tag_len: be_u32
- >> tag: cond!(tag_len > 0, take!(tag_len))
- >> min_ver: be_u32
+ >> _tag: cond!(tag_len > 0, take!(tag_len))
+ >> _min_ver: be_u32
>> ops_cnt: be_u32
>> commands: count!(parse_request_compound_command, ops_cnt as usize)
>> (Nfs4RequestCompoundRecord {
- commands: commands,
+ commands
})
));
do_parse!(
count: be_u32
>> committed: be_u32
- >> verifier: be_u64
+ >> _verifier: be_u64
>> (Nfs4ResponseWrite {
- count: count,
- committed: committed,
+ count,
+ committed
})
));
named!(nfs4_res_open_ok_delegate_read<Nfs4ResponseOpenDelegateRead>,
do_parse!(
stateid: nfs4_parse_stateid
- >> recall: be_u32
- >> ace_type: be_u32
- >> ace_flags: be_u32
- >> ace_mask: be_u32
+ >> _recall: be_u32
+ >> _ace_type: be_u32
+ >> _ace_flags: be_u32
+ >> _ace_mask: be_u32
>> who_len: be_u32
- >> who: take!(who_len)
+ >> _who: take!(who_len)
>> (Nfs4ResponseOpenDelegateRead {
- stateid: stateid,
+ stateid
})
));
named!(nfs4_res_open_ok<Nfs4ResponseOpen>,
do_parse!(
stateid: nfs4_parse_stateid
- >> change_info: take!(20)
+ >> _change_info: take!(20)
>> result_flags: be_u32
- >> attrs: nfs4_parse_attrbits
+ >> _attrs: nfs4_parse_attrbits
>> delegation_type: be_u32
>> delegate_read: cond!(delegation_type == 1, nfs4_res_open_ok_delegate_read)
>> ( Nfs4ResponseOpen {
- stateid: stateid, result_flags: result_flags,
- delegation_type: delegation_type,
- delegate_read: delegate_read,
+ stateid,
+ result_flags,
+ delegation_type,
+ delegate_read
} )
));
named!(nfs4_res_readdir_entry_do<Nfs4ResponseReaddirEntry>,
do_parse!(
- cookie: be_u64
+ _cookie: be_u64
>> name: nfs4_parse_nfsstring
- >> attrs: nfs4_parse_attrs
+ >> _attrs: nfs4_parse_attrs
>> ( Nfs4ResponseReaddirEntry {
name: name,
})
named!(nfs4_res_readdir_ok<Nfs4ResponseReaddir>,
do_parse!(
- verifier: be_u64
+ _verifier: be_u64
// run parser until we find a 'value follows == 0'
>> listing: many_till!(call!(nfs4_res_readdir_entry), peek!(tag!(b"\x00\x00\x00\x00")))
// value follows == 0 checked by line above
named!(nfs4_res_create_ok<Nfs4Attr>,
do_parse!(
- change_info: take!(20)
+ _change_info: take!(20)
>> attrs: nfs4_parse_attrbits
>> ( attrs )
));
named!(nfs4_res_create<Nfs4ResponseContent>,
do_parse!(
status: be_u32
- >> attrs: cond!(status == 0, nfs4_res_create_ok)
+ >> _attrs: cond!(status == 0, nfs4_res_create_ok)
>> ( Nfs4ResponseContent::Create(status) )
));
named!(nfs4_res_setattr<Nfs4ResponseContent>,
do_parse!(
status: be_u32
- >> attrs: cond!(status == 0, nfs4_res_setattr_ok)
+ >> _attrs: cond!(status == 0, nfs4_res_setattr_ok)
>> ( Nfs4ResponseContent::SetAttr(status) )
));
named!(nfs4_res_setclientid<Nfs4ResponseContent>,
do_parse!(
status: be_u32
- >> client_id: be_u64
- >> verifier: be_u32
+ >> _client_id: be_u64
+ >> _verifier: be_u32
>> ( Nfs4ResponseContent::SetClientId(status) )
));
named!(nfs4_res_commit<Nfs4ResponseContent>,
do_parse!(
status: be_u32
- >> verifier: cond!(status == 0, take!(8))
+ >> _verifier: cond!(status == 0, take!(8))
>> ( Nfs4ResponseContent::Commit(status))
));
do_parse!(
status: be_u32
>> tag_len: be_u32
- >> tag: cond!(tag_len > 0, take!(tag_len))
+ >> _tag: cond!(tag_len > 0, take!(tag_len))
>> ops_cnt: be_u32
>> commands: count!(nfs4_res_compound_command, ops_cnt as usize)
>> (Nfs4ResponseCompoundRecord {
named!(pub parse_dcerpc_bind_iface<DceRpcBindIface>,
do_parse!(
- ctx_id: le_u16
- >> num_trans_items: le_u8
+ _ctx_id: le_u16
+ >> _num_trans_items: le_u8
>> take!(1) // reserved
>> interface: take!(16)
>> ver: le_u16
named!(pub parse_dcerpc_bind_iface_big<DceRpcBindIface>,
do_parse!(
- ctx_id: le_u16
- >> num_trans_items: le_u8
+ _ctx_id: le_u16
+ >> _num_trans_items: le_u8
>> take!(1) // reserved
>> interface: take!(16)
>> ver_min: be_u16
named!(pub parse_dcerpc_bind_record<DceRpcBindRecord>,
do_parse!(
- max_xmit_frag: le_u16
- >> max_recv_frag: le_u16
- >> assoc_group: take!(4)
+ _max_xmit_frag: le_u16
+ >> _max_recv_frag: le_u16
+ >> _assoc_group: take!(4)
>> num_ctx_items: le_u8
>> take!(3) // reserved
>> ifaces: count!(parse_dcerpc_bind_iface, num_ctx_items as usize)
named!(pub parse_dcerpc_bind_record_big<DceRpcBindRecord>,
do_parse!(
- max_xmit_frag: be_u16
- >> max_recv_frag: be_u16
- >> assoc_group: take!(4)
+ _max_xmit_frag: be_u16
+ >> _max_recv_frag: be_u16
+ >> _assoc_group: take!(4)
>> num_ctx_items: le_u8
>> take!(3) // reserved
>> ifaces: count!(parse_dcerpc_bind_iface_big, num_ctx_items as usize)
named!(pub parse_dcerpc_bindack_record<DceRpcBindAckRecord>,
do_parse!(
- max_xmit_frag: le_u16
- >> max_recv_frag: le_u16
- >> assoc_group: take!(4)
+ _max_xmit_frag: le_u16
+ >> _max_recv_frag: le_u16
+ >> _assoc_group: take!(4)
>> sec_addr_len: le_u16
>> take!(sec_addr_len)
>> cond!((sec_addr_len+2) % 4 != 0, take!(4 - (sec_addr_len+2) % 4))
take_bits!(u32, 28)))
>> endian: value!(if data_rep.1 == 0 { Endianness::Big } else { Endianness::Little })
>> frag_len: u16!(endian)
- >> auth: u16!(endian)
+ >> _auth: u16!(endian)
>> call_id: u32!(endian)
>> data:rest
>> (DceRpcRecord {
named!(pub parse_ntlm_auth_record<NTLMSSPAuthRecord>,
do_parse!(
- lm_blob_len: le_u16
- >> lm_blob_maxlen: le_u16
- >> lm_blob_offset: le_u32
+ _lm_blob_len: le_u16
+ >> _lm_blob_maxlen: le_u16
+ >> _lm_blob_offset: le_u32
- >> ntlmresp_blob_len: le_u16
- >> ntlmresp_blob_maxlen: le_u16
- >> ntlmresp_blob_offset: le_u32
+ >> _ntlmresp_blob_len: le_u16
+ >> _ntlmresp_blob_maxlen: le_u16
+ >> _ntlmresp_blob_offset: le_u32
>> domain_blob_len: le_u16
- >> domain_blob_maxlen: le_u16
+ >> _domain_blob_maxlen: le_u16
>> domain_blob_offset: le_u32
>> user_blob_len: le_u16
- >> user_blob_maxlen: le_u16
- >> user_blob_offset: le_u32
+ >> _user_blob_maxlen: le_u16
+ >> _user_blob_offset: le_u32
>> host_blob_len: le_u16
- >> host_blob_maxlen: le_u16
- >> host_blob_offset: le_u32
+ >> _host_blob_maxlen: le_u16
+ >> _host_blob_offset: le_u32
- >> ssnkey_blob_len: le_u16
- >> ssnkey_blob_maxlen: le_u16
- >> ssnkey_blob_offset: le_u32
+ >> _ssnkey_blob_len: le_u16
+ >> _ssnkey_blob_maxlen: le_u16
+ >> _ssnkey_blob_offset: le_u32
>> nego_flags: bits!(tuple!(take_bits!(u8, 6),take_bits!(u8,1),take_bits!(u32,25)))
>> version: cond!(nego_flags.1==1, parse_ntlm_auth_version)
named!(pub parse_smb1_write_request_record<Smb1WriteRequestRecord>,
do_parse!(
- wct: le_u8
+ _wct: le_u8
>> fid: take!(2)
- >> count: le_u16
+ >> _count: le_u16
>> offset: le_u32
- >> remaining: le_u16
- >> bcc: le_u16
- >> buffer_format: le_u8
+ >> _remaining: le_u16
+ >> _bcc: le_u16
+ >> _buffer_format: le_u8
>> data_len: le_u16
>> file_data: take!(data_len)
>> (Smb1WriteRequestRecord {
offset: offset as u64,
len: data_len as u32,
- fid:fid,
+ fid,
data:file_data,
}))
);
named!(pub parse_smb1_write_andx_request_record<Smb1WriteRequestRecord>,
do_parse!(
wct: le_u8
- >> andx_command: le_u8
+ >> _andx_command: le_u8
>> take!(1) // reserved
- >> andx_offset: le_u16
+ >> _andx_offset: le_u16
>> fid: take!(2)
>> offset: le_u32
>> take!(4) // reserved
- >> write_mode: le_u16
- >> remaining: le_u16
+ >> _write_mode: le_u16
+ >> _remaining: le_u16
>> data_len_high: le_u16
>> data_len_low: le_u16
- >> data_offset: le_u16
+ >> _data_offset: le_u16
>> high_offset: cond!(wct==14,le_u32)
>> bcc: le_u16
//>> padding: cond!(data_offset > 32, take!(data_offset - 32))
- >> padding: cond!(bcc > data_len_low, take!(bcc - data_len_low)) // TODO figure out how this works with data_len_high
+ >> _padding: cond!(bcc > data_len_low, take!(bcc - data_len_low)) // TODO figure out how this works with data_len_high
>> file_data: rest
>> (Smb1WriteRequestRecord {
offset: if high_offset != None { ((high_offset.unwrap() as u64) << 32)|(offset as u64) } else { 0 },
len: (((data_len_high as u32) << 16) as u32)|(data_len_low as u32),
- fid:fid,
+ fid,
data:file_data,
}))
);
named!(pub parse_smb1_write_and_close_request_record<Smb1WriteRequestRecord>,
do_parse!(
- wct: le_u8
+ _wct: le_u8
>> fid: take!(2)
>> count: le_u16
>> offset: le_u32
- >> last_write: take!(4)
+ >> _last_write: take!(4)
>> bcc: le_u16
- >> padding: cond!(bcc > count, take!(bcc - count))
+ >> _padding: cond!(bcc > count, take!(bcc - count))
>> file_data: take!(count)
>> (Smb1WriteRequestRecord {
offset: offset as u64,
len: count as u32,
- fid:fid,
+ fid,
data:file_data,
}))
);
named!(pub parse_smb1_negotiate_protocol_response_record_error<Smb1NegotiateProtocolResponseRecord>,
do_parse!(
- wct: le_u8
- >> bcc: le_u16
+ _wct: le_u8
+ >> _bcc: le_u16
>> ( Smb1NegotiateProtocolResponseRecord {
dialect_idx: 0,
server_guid: &[],
named!(pub parse_smb1_negotiate_protocol_response_record_ok<Smb1NegotiateProtocolResponseRecord>,
do_parse!(
- wct: le_u8
+ _wct: le_u8
>> dialect_idx: le_u16
- >> sec_mode: le_u8
+ >> _sec_mode: le_u8
>> take!(16)
- >> caps: le_u32
- >> sys_time: le_u64
- >> server_tz: le_u16
- >> challenge_len: le_u8
+ >> _caps: le_u32
+ >> _sys_time: le_u64
+ >> _server_tz: le_u16
+ >> _challenge_len: le_u8
>> bcc: le_u16
>> server_guid: cond!(bcc >= 16, take!(16))
>> (Smb1NegotiateProtocolResponseRecord {
- dialect_idx:dialect_idx,
+ dialect_idx,
server_guid: server_guid.unwrap_or(&[]),
}))
);
named!(pub parse_smb1_negotiate_protocol_record<Smb1NegotiateProtocolRecord>,
do_parse!(
- wtc: le_u8
- >> bcc: le_u16
+ _wtc: le_u8
+ >> _bcc: le_u16
// dialects is a list of [1 byte buffer format][string][0 terminator]
>> dialects: many1!(take_until_and_consume!("\0"))
>> (Smb1NegotiateProtocolRecord {
- dialects:dialects,
+ dialects
}))
);
named!(pub parse_smb_connect_tree_andx_response_record<Smb1ResponseRecordTreeConnectAndX>,
do_parse!(
wct: le_u8
- >> andx_command: le_u8
+ >> _andx_command: le_u8
>> take!(1) // reserved
- >> andx_offset: le_u16
+ >> _andx_offset: le_u16
>> cond!(wct >= 3, take!(2)) // optional support
>> cond!(wct == 7, take!(8)) // access masks
- >> bcc: le_u16
+ >> _bcc: le_u16
>> service: take_until_and_consume!("\x00")
>> nativefs: take_until_and_consume!("\x00")
>> (Smb1ResponseRecordTreeConnectAndX {
- service:service,
- nativefs:nativefs,
+ service,
+ nativefs
}))
);
>> path: apply!(smb1_get_string, r, 11 + pwlen as usize)
>> service: take_until_and_consume!("\x00")
>> (SmbRecordTreeConnectAndX {
- path: path,
- service: service,
+ path,
+ service
}))
}
>> fid: take!(2)
>> (SmbPipeProtocolRecord {
function: fun,
- fid: fid,
+ fid
})
)
);
named!(pub parse_smb_trans_request_record_params<(SmbRecordTransRequestParams, Option<SmbPipeProtocolRecord>)>,
do_parse!(
wct: le_u8
- >> total_param_cnt: le_u16
- >> total_data_count: le_u16
- >> max_param_cnt: le_u16
+ >> _total_param_cnt: le_u16
+ >> _total_data_count: le_u16
+ >> _max_param_cnt: le_u16
>> max_data_cnt: le_u16
- >> max_setup_cnt: le_u8
+ >> _max_setup_cnt: le_u8
>> take!(1) // reserved
>> take!(2) // flags
- >> timeout: le_u32
+ >> _timeout: le_u32
>> take!(2) // reserved
>> param_cnt: le_u16
>> param_offset: le_u16
>> pipe: cond!(wct == 16 && setup_cnt == 2, parse_smb_trans_request_record_pipe)
>> bcc: le_u16
>> (( SmbRecordTransRequestParams {
- max_data_cnt:max_data_cnt,
- param_cnt:param_cnt,
- param_offset:param_offset,
- data_cnt:data_cnt,
- data_offset:data_offset,
- bcc:bcc,
+ max_data_cnt,
+ param_cnt,
+ param_offset,
+ data_cnt,
+ data_offset,
+ bcc
},
pipe)))
);
named!(pub parse_smb_trans_response_error_record<SmbRecordTransResponse>,
do_parse!(
- wct: le_u8
+ _wct: le_u8
>> bcc: le_u16
>> (SmbRecordTransResponse {
data_cnt:0,
named!(pub parse_smb_trans_response_regular_record<SmbRecordTransResponse>,
do_parse!(
- wct: le_u8
- >> total_param_cnt: le_u16
- >> total_data_count: le_u16
+ _wct: le_u8
+ >> _total_param_cnt: le_u16
+ >> _total_data_count: le_u16
>> take!(2) // reserved
- >> param_cnt: le_u16
- >> param_offset: le_u16
- >> param_displacement: le_u16
+ >> _param_cnt: le_u16
+ >> _param_offset: le_u16
+ >> _param_displacement: le_u16
>> data_cnt: le_u16
- >> data_offset: le_u16
- >> data_displacement: le_u16
- >> setup_cnt: le_u8
+ >> _data_offset: le_u16
+ >> _data_displacement: le_u16
+ >> _setup_cnt: le_u8
>> take!(1) // reserved
>> bcc: le_u16
>> take!(1) // padding
>> data: take!(data_cnt)
>> (SmbRecordTransResponse {
- data_cnt:data_cnt,
- bcc:bcc,
- data:data,
+ data_cnt,
+ bcc,
+ data
}))
);
named!(pub parse_smb_setup_andx_record<SmbRecordSetupAndX>,
do_parse!(
- skip1: take!(15)
+ _skip1: take!(15)
>> sec_blob_len: le_u16
- >> skip2: take!(8)
- >> bcc: le_u16
+ >> _skip2: take!(8)
+ >> _bcc: le_u16
>> sec_blob: take!(sec_blob_len)
>> (SmbRecordSetupAndX {
- sec_blob:sec_blob,
+ sec_blob
}))
);
named!(response_setup_andx_record<SmbResponseRecordSetupAndX>,
do_parse!(
- skip1: take!(7)
+ _skip1: take!(7)
>> sec_blob_len: le_u16
- >> bcc: le_u16
+ >> _bcc: le_u16
>> sec_blob: take!(sec_blob_len)
>> (SmbResponseRecordSetupAndX {
- sec_blob:sec_blob,
+ sec_blob
}))
);
named!(response_setup_andx_wct3_record<SmbResponseRecordSetupAndX>,
do_parse!(
- skip1: take!(7)
- >> bcc: le_u16
+ _skip1: take!(7)
+ >> _bcc: le_u16
>> (SmbResponseRecordSetupAndX {
sec_blob:&[],
}))
named!(response_setup_andx_error_record<SmbResponseRecordSetupAndX>,
do_parse!(
- wct: le_u8
- >> bcc: le_u16
+ _wct: le_u8
+ >> _bcc: le_u16
>> (SmbResponseRecordSetupAndX {
sec_blob: &[],
}))
named!(pub parse_smb_read_andx_request_record<SmbRequestReadAndXRecord>,
do_parse!(
wct: le_u8
- >> andx_command: le_u8
+ >> _andx_command: le_u8
>> take!(1) // reserved
- >> andx_offset: le_u16
+ >> _andx_offset: le_u16
>> fid: take!(2)
>> offset: le_u32
>> max_count_low: le_u16
>> take!(2)
>> high_offset: cond!(wct==12,le_u32) // only from wct ==12?
>> (SmbRequestReadAndXRecord {
- fid:fid,
+ fid,
size: (((max_count_high as u64) << 16)|max_count_low as u64),
offset: if high_offset != None { ((high_offset.unwrap() as u64) << 32)|(offset as u64) } else { 0 },
}))
named!(pub parse_smb_read_andx_response_record<SmbResponseReadAndXRecord>,
do_parse!(
- wct: le_u8
- >> andx_command: le_u8
+ _wct: le_u8
+ >> _andx_command: le_u8
>> take!(1) // reserved
- >> andx_offset: le_u16
+ >> _andx_offset: le_u16
>> take!(6)
>> data_len_low: le_u16
- >> data_offset: le_u16
+ >> _data_offset: le_u16
>> data_len_high: le_u32
>> take!(6) // reserved
>> bcc: le_u16
- >> padding: cond!(bcc > data_len_low, take!(bcc - data_len_low)) // TODO figure out how this works with data_len_high
+ >> _padding: cond!(bcc > data_len_low, take!(bcc - data_len_low)) // TODO figure out how this works with data_len_high
>> file_data: rest
>> (SmbResponseReadAndXRecord {
named!(pub parse_smb_rename_request_record<SmbRequestRenameRecord>,
do_parse!(
- wct: le_u8
- >> search_attr: le_u16
- >> bcc: le_u16
- >> oldtype: le_u8
+ _wct: le_u8
+ >> _search_attr: le_u16
+ >> _bcc: le_u16
+ >> _oldtype: le_u8
>> oldname: smb_get_unicode_string
- >> newtype: le_u8
+ >> _newtype: le_u8
>> newname: apply!(smb_get_unicode_string_with_offset, 1) // HACK if we assume oldname is a series of utf16 chars offset would be 1
>> (SmbRequestRenameRecord {
- oldname: oldname,
- newname: newname,
+ oldname,
+ newname
}))
);
named!(pub parse_smb_create_andx_request_record<SmbRequestCreateAndXRecord>,
do_parse!(
- skip1: take!(6)
+ _skip1: take!(6)
>> file_name_len: le_u16
- >> skip3: take!(28)
+ >> _skip3: take!(28)
>> disposition: le_u32
>> create_options: le_u32
- >> skip2: take!(8)
+ >> _skip2: take!(8)
>> file_name: take!(file_name_len)
- >> skip3: rest
+ >> _skip3: rest
>> (SmbRequestCreateAndXRecord {
disposition: disposition,
create_options: create_options,
do_parse!(
replace: le_u8
>> _reserved: take!(3)
- >> root_dir: take!(4)
+ >> _root_dir: take!(4)
>> newname_len: le_u32
>> newname: take!(newname_len)
>> (Trans2RecordParamSetFileInfoRename {
>> _reserved: take!(4)
>> oldname: call!(smb_get_unicode_string)
>> (Trans2RecordParamSetPathInfo {
- loi:loi,
- oldname:oldname,
+ loi,
+ oldname
})
));
do_parse!(
replace: le_u8
>> _reserved: take!(3)
- >> root_dir: take!(4)
+ >> _root_dir: take!(4)
>> newname_len: le_u32
>> newname: take!(newname_len)
>> (Trans2RecordParamSetPathInfoRename {
replace: replace==1,
- newname: newname,
+ newname
})
));
named!(pub parse_smb_trans2_request_record<SmbRequestTrans2Record>,
do_parse!(
- wct: le_u8
- >> total_param_cnt: le_u16
- >> total_data_cnt: le_u16
- >> max_param_cnt: le_u16
- >> max_data_cnt: le_u16
- >> max_setup_cnt: le_u8
+ _wct: le_u8
+ >> _total_param_cnt: le_u16
+ >> _total_data_cnt: le_u16
+ >> _max_param_cnt: le_u16
+ >> _max_data_cnt: le_u16
+ >> _max_setup_cnt: le_u8
>> _reserved1: take!(1)
- >> flags: le_u16
- >> timeout: le_u32
+ >> _flags: le_u16
+ >> _timeout: le_u32
>> _reserved2: take!(2)
>> param_cnt: le_u16
- >> param_offset: le_u16
+ >> _param_offset: le_u16
>> data_cnt: le_u16
- >> data_offset: le_u16
- >> setup_cnt: le_u8
+ >> _data_offset: le_u16
+ >> _setup_cnt: le_u8
>> _reserved3: take!(1)
>> subcmd: le_u16
- >> bcc: le_u16
+ >> _bcc: le_u16
>> _padding: take!(3)
>> setup_blob: take!(param_cnt)
>> data_blob: take!(data_cnt)
>> (SmbRequestTrans2Record {
- subcmd: subcmd,
- setup_blob: setup_blob,
- data_blob: data_blob,
+ subcmd,
+ setup_blob,
+ data_blob
}))
);
named!(pub parse_smb_create_andx_response_record<SmbResponseCreateAndXRecord>,
do_parse!(
wct: le_u8
- >> andx_command: le_u8
+ >> _andx_command: le_u8
>> take!(1) // reserved
- >> andx_offset: le_u16
- >> oplock_level: le_u8
+ >> _andx_offset: le_u16
+ >> _oplock_level: le_u8
>> fid: take!(2)
- >> create_action: le_u32
+ >> _create_action: le_u32
>> create_ts: le_u64
>> last_access_ts: le_u64
>> last_write_ts: le_u64
>> last_change_ts: le_u64
>> take!(4)
>> file_size: le_u64
- >> eof: le_u64
- >> file_type: le_u16
- >> ipc_state: le_u16
- >> is_dir: le_u8
+ >> _eof: le_u64
+ >> _file_type: le_u16
+ >> _ipc_state: le_u16
+ >> _is_dir: le_u8
>> cond!(wct == 42, take!(32))
- >> bcc: le_u16
+ >> _bcc: le_u16
>> (SmbResponseCreateAndXRecord {
fid:fid,
create_ts: SMBFiletime::new(create_ts),
>> flags:le_u8
>> flags2:le_u16
>> process_id_high:le_u16
- >> signature:take!(8)
- >> reserved:take!(2)
+ >> _signature:take!(8)
+ >> _reserved:take!(2)
>> tree_id:le_u16
>> process_id:le_u16
>> user_id:le_u16
named!(pub parse_smb2_request_record<Smb2Record>,
do_parse!(
- server_component: tag!(b"\xfeSMB")
+ _server_component: tag!(b"\xfeSMB")
>> hlen: le_u16
- >> credit_charge: le_u16
- >> channel_seq: le_u16
- >> reserved: take!(2)
+ >> _credit_charge: le_u16
+ >> _channel_seq: le_u16
+ >> _reserved: take!(2)
>> command: le_u16
- >> credits_requested: le_u16
+ >> _credits_requested: le_u16
>> flags: bits!(tuple!(
take_bits!(u8, 2), // reserved / unused
take_bits!(u8, 1), // replay op
))
>> chain_offset: le_u32
>> message_id: le_u64
- >> process_id: le_u32
+ >> _process_id: le_u32
>> tree_id: le_u32
>> session_id: le_u64
- >> signature: take!(16)
+ >> _signature: take!(16)
// there is probably a cleaner way to do this
>> data_c: cond!(chain_offset > hlen as u32, take!(chain_offset - hlen as u32))
>> data_r: cond!(chain_offset <= hlen as u32, rest)
named!(pub parse_smb2_request_negotiate_protocol<Smb2NegotiateProtocolRequestRecord>,
do_parse!(
- struct_size: take!(2)
+ _struct_size: take!(2)
>> dialects_count: le_u16
- >> sec_mode: le_u16
- >> reserved1: le_u16
- >> capabilities: le_u32
+ >> _sec_mode: le_u16
+ >> _reserved1: le_u16
+ >> _capabilities: le_u32
>> client_guid: take!(16)
- >> ctx_offset: le_u32
- >> ctx_cnt: le_u16
- >> reserved2: le_u16
+ >> _ctx_offset: le_u32
+ >> _ctx_cnt: le_u16
+ >> _reserved2: le_u16
>> dia_vec: count!(le_u16, dialects_count as usize)
>> (Smb2NegotiateProtocolRequestRecord {
dialects_vec: dia_vec,
named!(pub parse_smb2_response_negotiate_protocol<Smb2NegotiateProtocolResponseRecord>,
do_parse!(
- struct_size: take!(2)
- >> skip1: take!(2)
+ _struct_size: take!(2)
+ >> _skip1: take!(2)
>> dialect: le_u16
- >> ctx_cnt: le_u16
+ >> _ctx_cnt: le_u16
>> server_guid: take!(16)
>> (Smb2NegotiateProtocolResponseRecord {
- dialect: dialect,
- server_guid: server_guid,
+ dialect,
+ server_guid
})
));
named!(pub parse_smb2_response_negotiate_protocol_error<Smb2NegotiateProtocolResponseRecord>,
do_parse!(
- struct_size: take!(2)
- >> skip1: take!(2)
+ _struct_size: take!(2)
+ >> _skip1: take!(2)
>> (Smb2NegotiateProtocolResponseRecord {
dialect: 0,
server_guid: &[],
named!(pub parse_smb2_request_session_setup<Smb2SessionSetupRequestRecord>,
do_parse!(
- struct_size: take!(2)
- >> flags: le_u8
- >> security_mode: le_u8
- >> capabilities: le_u32
- >> channel: le_u32
- >> sec_offset: le_u16
- >> sec_len: le_u16
- >> prev_ssn_id: take!(8)
+ _struct_size: take!(2)
+ >> _flags: le_u8
+ >> _security_mode: le_u8
+ >> _capabilities: le_u32
+ >> _channel: le_u32
+ >> _sec_offset: le_u16
+ >> _sec_len: le_u16
+ >> _prev_ssn_id: take!(8)
>> data: rest
>> (Smb2SessionSetupRequestRecord {
data:data,
named!(pub parse_smb2_request_tree_connect<Smb2TreeConnectRequestRecord>,
do_parse!(
- struct_size: take!(2)
- >> offset_length: take!(4)
+ _struct_size: take!(2)
+ >> _offset_length: take!(4)
>> data: rest
>> (Smb2TreeConnectRequestRecord {
share_name:data,
named!(pub parse_smb2_response_tree_connect<Smb2TreeConnectResponseRecord>,
do_parse!(
- struct_size: take!(2)
+ _struct_size: take!(2)
>> share_type: le_u8
- >> share_flags: le_u32
- >> share_caps: le_u32
- >> access_mask: le_u32
+ >> _share_flags: le_u32
+ >> _share_caps: le_u32
+ >> _access_mask: le_u32
>> (Smb2TreeConnectResponseRecord {
- share_type:share_type,
+ share_type
})
));
named!(pub parse_smb2_request_create<Smb2CreateRequestRecord>,
do_parse!(
- skip1: take!(36)
+ _skip1: take!(36)
>> disposition: le_u32
>> create_options: le_u32
- >> file_name_offset: le_u16
+ >> _file_name_offset: le_u16
>> file_name_length: le_u16
- >> skip2: take!(8)
+ >> _skip2: take!(8)
>> data: take!(file_name_length)
- >> skip3: rest
+ >> _skip3: rest
>> (Smb2CreateRequestRecord {
- disposition: disposition,
- create_options: create_options,
- data:data,
+ disposition,
+ create_options,
+ data
})
));
named!(pub parse_smb2_request_ioctl<Smb2IOCtlRequestRecord>,
do_parse!(
- skip: take!(2) // structure size
+ _skip: take!(2) // structure size
>> take!(2) // reserved
>> func: le_u32
>> guid: take!(16)
- >> indata_offset: le_u32
+ >> _indata_offset: le_u32
>> indata_len: le_u32
>> take!(4)
- >> outdata_offset: le_u32
- >> outdata_len: le_u32
+ >> _outdata_offset: le_u32
+ >> _outdata_len: le_u32
>> take!(12)
>> data: take!(indata_len)
>> (Smb2IOCtlRequestRecord {
named!(pub parse_smb2_response_ioctl<Smb2IOCtlResponseRecord>,
do_parse!(
- skip: take!(2) // structure size
+ _skip: take!(2) // structure size
>> take!(2) // reserved
>> func: le_u32
>> guid: take!(16)
named!(pub parse_smb2_request_close<Smb2CloseRequestRecord>,
do_parse!(
- skip: take!(8)
+ _skip: take!(8)
>> guid: take!(16)
>> (Smb2CloseRequestRecord {
- guid:guid,
+ guid
})
));
named!(pub parse_smb2_request_setinfo_rename<Smb2SetInfoRequestRenameRecord>,
do_parse!(
- replace: le_u8
+ _replace: le_u8
>> _reserved: take!(7)
>> _root_handle: take!(8)
>> name_len: le_u32
>> name: take!(name_len)
>> (Smb2SetInfoRequestRenameRecord {
- name: name,
+ name
})
));
named!(pub parse_smb2_request_setinfo<Smb2SetInfoRequestRecord>,
do_parse!(
- struct_size: le_u16
+ _struct_size: le_u16
>> class: le_u8
>> infolvl: le_u8
>> setinfo_size: le_u32
- >> setinfo_offset: le_u16
+ >> _setinfo_offset: le_u16
>> _reserved: take!(2)
- >> additional_info: le_u32
+ >> _additional_info: le_u32
>> guid: take!(16)
>> rename: cond!(class == 1 && infolvl == 10, flat_map!(take!(setinfo_size),parse_smb2_request_setinfo_rename))
>> (Smb2SetInfoRequestRecord {
// can be called on incomplete records
named!(pub parse_smb2_request_write<Smb2WriteRequestRecord>,
do_parse!(
- skip1: take!(4)
+ _skip1: take!(4)
>> wr_len: le_u32
>> wr_offset: le_u64
>> guid: take!(16)
- >> channel: le_u32
- >> remaining_bytes: le_u32
- >> write_flags: le_u32
- >> skip2: take!(4)
+ >> _channel: le_u32
+ >> _remaining_bytes: le_u32
+ >> _write_flags: le_u32
+ >> _skip2: take!(4)
>> data: apply!(parse_smb2_data, wr_len)
>> (Smb2WriteRequestRecord {
wr_len:wr_len,
named!(pub parse_smb2_request_read<Smb2ReadRequestRecord>,
do_parse!(
- skip1: take!(4)
+ _skip1: take!(4)
>> rd_len: le_u32
>> rd_offset: le_u64
>> guid: take!(16)
- >> min_count: le_u32
- >> channel: le_u32
- >> remaining_bytes: le_u32
- >> skip2: take!(4)
+ >> _min_count: le_u32
+ >> _channel: le_u32
+ >> _remaining_bytes: le_u32
+ >> _skip2: take!(4)
>> (Smb2ReadRequestRecord {
rd_len:rd_len,
rd_offset:rd_offset,
// can be called on incomplete records
named!(pub parse_smb2_response_read<Smb2ReadResponseRecord>,
do_parse!(
- struct_size: le_u16
- >> data_offset: le_u16
+ _struct_size: le_u16
+ >> _data_offset: le_u16
>> rd_len: le_u32
- >> rd_rem: le_u32
+ >> _rd_rem: le_u32
>> _padding: take!(4)
>> data: apply!(parse_smb2_data, rd_len)
>> (Smb2ReadResponseRecord {
named!(pub parse_smb2_response_create<Smb2CreateResponseRecord>,
do_parse!(
- ssize: le_u16
- >> oplock: le_u8
- >> resp_flags: le_u8
- >> create_action: le_u32
+ _ssize: le_u16
+ >> _oplock: le_u8
+ >> _resp_flags: le_u8
+ >> _create_action: le_u32
>> create_ts: le_u64
>> last_access_ts: le_u64
>> last_write_ts: le_u64
>> last_change_ts: le_u64
- >> alloc_size: le_u64
+ >> _alloc_size: le_u64
>> eof: le_u64
- >> attrs: le_u32
- >> padding: take!(4)
+ >> _attrs: le_u32
+ >> _padding: take!(4)
>> guid: take!(16)
- >> skip2: take!(8)
+ >> _skip2: take!(8)
>> (Smb2CreateResponseRecord {
guid : guid,
create_ts: SMBFiletime::new(create_ts),
named!(pub parse_smb2_response_write<Smb2WriteResponseRecord>,
do_parse!(
- skip1: take!(4)
+ _skip1: take!(4)
>> wr_cnt: le_u32
- >> skip2: take!(6)
+ >> _skip2: take!(6)
>> (Smb2WriteResponseRecord {
wr_cnt : wr_cnt,
})
do_parse!(
tag!(b"\xfeSMB")
>> hlen: le_u16
- >> credit_charge: le_u16
+ >> _credit_charge: le_u16
>> nt_status: le_u32
>> command: le_u16
- >> credit_granted: le_u16
+ >> _credit_granted: le_u16
>> flags: bits!(tuple!(
take_bits!(u8, 2), // reserved / unused
take_bits!(u8, 1), // replay op
))
>> chain_offset: le_u32
>> message_id: le_u64
- >> process_id: cond!(flags.6==0, le_u32)
+ >> _process_id: cond!(flags.6==0, le_u32)
>> tree_id: cond!(flags.6==0, le_u32)
>> async_id: cond!(flags.6==1, le_u64)
>> session_id: le_u64
- >> signature: take!(16)
+ >> _signature: take!(16)
// there is probably a cleaner way to do this
>> data_c: cond!(chain_offset > hlen as u32, take!(chain_offset - hlen as u32))
>> data_r: cond!(chain_offset <= hlen as u32, rest)
named!(pub parse_smb3_transform_record<Smb3TransformRecord>,
do_parse!(
tag!(b"\xfdSMB")
- >> signature: take!(16)
- >> nonce: take!(16)
+ >> _signature: take!(16)
+ >> _nonce: take!(16)
>> msg_size: le_u32
- >> reserved: le_u16
+ >> _reserved: le_u16
>> enc_algo: le_u16
>> session_id: le_u64
>> enc_data: take!(msg_size)
>> ( Smb3TransformRecord {
- session_id: session_id,
- enc_algo: enc_algo,
- enc_data: enc_data,
+ session_id,
+ enc_algo,
+ enc_data,
})
));
projects / thirdparty / suricata.git / commitdiff
