From: Pierre Chifflier Date: Fri, 8 Feb 2019 13:30:17 +0000 (+0100) Subject: rust: fix warnings for unused variables (add _) X-Git-Tag: suricata-5.0.0-beta1~226 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=8c0cde36c6671147ea3d1e79ae4c1044ec9c9975;p=thirdparty%2Fsuricata.git rust: fix warnings for unused variables (add _) --- diff --git a/rust/src/applayertemplate/parser.rs b/rust/src/applayertemplate/parser.rs index acc8bd8416..dc56fbeaf5 100644 --- a/rust/src/applayertemplate/parser.rs +++ b/rust/src/applayertemplate/parser.rs @@ -23,10 +23,10 @@ fn parse_len(input: &str) -> Result { named!(pub parse_message, 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() ) diff --git a/rust/src/dhcp/parser.rs b/rust/src/dhcp/parser.rs index 18069d13f9..c50ffd6fc6 100644 --- a/rust/src/dhcp/parser.rs +++ b/rust/src/dhcp/parser.rs @@ -120,10 +120,10 @@ named!(pub parse_header, named!(pub parse_clientid_option, 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, @@ -139,8 +139,8 @@ named!(pub parse_clientid_option, named!(pub parse_address_time_option, do_parse!( - code: be_u8 >> - len: be_u8 >> + code: be_u8 >> + _len: be_u8 >> seconds: be_u32 >> ( DHCPOption{ diff --git a/rust/src/nfs/nfs2_records.rs b/rust/src/nfs/nfs2_records.rs index 46663eb29f..686d9d48ff 100644 --- a/rust/src/nfs/nfs2_records.rs +++ b/rust/src/nfs/nfs2_records.rs @@ -45,10 +45,10 @@ named!(pub parse_nfs2_request_lookup, 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(), } )) @@ -64,11 +64,11 @@ named!(pub parse_nfs2_request_read, do_parse!( handle: parse_nfs2_handle >> offset: be_u32 - >> count: be_u32 + >> _count: be_u32 >> ( Nfs2RequestRead { - handle:handle, - offset:offset, + handle, + offset } )) ); @@ -81,12 +81,12 @@ named!(pub parse_nfs2_reply_read, >> 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, } )) @@ -101,13 +101,13 @@ pub struct Nfs2Attributes<> { named!(pub parse_nfs2_attribs, 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 } )) ); diff --git a/rust/src/nfs/nfs3_records.rs b/rust/src/nfs/nfs3_records.rs index 9659c626f5..4513a1a8cc 100644 --- a/rust/src/nfs/nfs3_records.rs +++ b/rust/src/nfs/nfs3_records.rs @@ -114,7 +114,7 @@ named!(pub parse_nfs3_request_remove, handle: parse_nfs3_handle >> name_len: be_u32 >> name: take!(name_len) - >> fill_bytes: rest + >> _fill_bytes: rest >> ( Nfs3RequestRemove { handle:handle, @@ -135,7 +135,7 @@ named!(pub parse_nfs3_request_rmdir, 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, @@ -155,8 +155,8 @@ named!(pub parse_nfs3_request_mkdir, 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, @@ -178,16 +178,16 @@ named!(pub parse_nfs3_request_rename, 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(), } )) @@ -234,11 +234,11 @@ pub struct Nfs3RequestCommit<'a> { named!(pub parse_nfs3_request_commit, do_parse!( handle: parse_nfs3_handle - >> offset: be_u64 - >> count: be_u32 + >> _offset: be_u64 + >> _count: be_u32 >> ( Nfs3RequestCommit { - handle:handle, + handle } )) ); @@ -253,11 +253,11 @@ named!(pub parse_nfs3_request_read, do_parse!( handle: parse_nfs3_handle >> offset: be_u64 - >> count: be_u32 + >> _count: be_u32 >> ( Nfs3RequestRead { - handle:handle, - offset:offset, + handle, + offset } )) ); @@ -274,10 +274,10 @@ named!(pub parse_nfs3_request_lookup, 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(), } )) @@ -292,19 +292,19 @@ pub struct Nfs3ResponseReaddirplusEntryC<'a> { named!(pub parse_nfs3_response_readdirplus_entry, 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, } ) ) @@ -317,11 +317,11 @@ pub struct Nfs3ResponseReaddirplusEntry<'a> { named!(pub parse_nfs3_response_readdirplus_entry_cond, do_parse!( - value_follows: be_u32 + value_follows: be_u32 >> entry: cond!(value_follows==1, parse_nfs3_response_readdirplus_entry) >> ( Nfs3ResponseReaddirplusEntry { - entry:entry, + entry } )) ); @@ -336,13 +336,13 @@ named!(pub parse_nfs3_response_readdirplus, 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 } )) ); diff --git a/rust/src/nfs/nfs4_records.rs b/rust/src/nfs/nfs4_records.rs index 52684a83ad..f758a86c4c 100644 --- a/rust/src/nfs/nfs4_records.rs +++ b/rust/src/nfs/nfs4_records.rs @@ -139,23 +139,23 @@ pub struct Nfs4RequestSetClientId<'a> { named!(nfs4_req_setclientid, 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, do_parse!( - client_id: take!(8) - >> verifier: take!(8) + _client_id: take!(8) + >> _verifier: take!(8) >> (Nfs4RequestContent::SetClientIdConfirm) )); @@ -171,7 +171,7 @@ named!(nfs4_req_create, 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, @@ -225,31 +225,31 @@ pub struct Nfs4RequestOpen<'a> { named!(nfs4_req_open, 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, 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 ) ) ); @@ -265,8 +265,8 @@ named!(nfs4_req_rename, oldname: nfs4_parse_nfsstring >> newname: nfs4_parse_nfsstring >> ( Nfs4RequestContent::Rename(Nfs4RequestRename { - oldname: oldname, - newname: newname, + oldname, + newname }) )) ); @@ -280,7 +280,7 @@ named!(nfs4_req_lookup, do_parse!( filename: nfs4_parse_nfsstring >> ( Nfs4RequestContent::Lookup(Nfs4RequestLookup { - filename: filename, + filename }) )) ); @@ -299,9 +299,9 @@ pub struct Nfs4RequestSetAttr<'a> { named!(nfs4_req_setattr, do_parse!( stateid: nfs4_parse_stateid - >> attrs: nfs4_parse_attrs + >> _attrs: nfs4_parse_attrs >> (Nfs4RequestContent::SetAttr(Nfs4RequestSetAttr { - stateid: stateid, + stateid })) )); @@ -360,7 +360,7 @@ named!(nfs4_req_read, named!(nfs4_req_close, do_parse!( - seqid: be_u32 + _seqid: be_u32 >> stateid: nfs4_parse_stateid >> ( Nfs4RequestContent::Close(stateid) ) )); @@ -373,9 +373,9 @@ pub struct Nfs4RequestOpenConfirm<'a> { named!(nfs4_req_open_confirm, do_parse!( stateid: nfs4_parse_stateid - >> seqid: be_u32 + >> _seqid: be_u32 >> ( Nfs4RequestContent::OpenConfirm(Nfs4RequestOpenConfirm { - stateid: stateid, + stateid }) )) ); @@ -412,8 +412,8 @@ named!(nfs4_req_access, named!(nfs4_req_commit, do_parse!( - offset: be_u64 - >> count: be_u32 + _offset: be_u64 + >> _count: be_u32 >> ( Nfs4RequestContent::Commit ) ) ); @@ -427,20 +427,20 @@ pub struct Nfs4RequestExchangeId<'a> { named!(nfs4_req_exchangeid, 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 } )) )); @@ -453,13 +453,13 @@ pub struct Nfs4RequestSequence<'a> { named!(nfs4_req_sequence, 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 } )) )); @@ -504,12 +504,12 @@ pub struct Nfs4RequestCompoundRecord<'a> { named!(pub parse_nfs4_request_compound, 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 }) )); @@ -550,10 +550,10 @@ named!(nfs4_res_write_ok, do_parse!( count: be_u32 >> committed: be_u32 - >> verifier: be_u64 + >> _verifier: be_u64 >> (Nfs4ResponseWrite { - count: count, - committed: committed, + count, + committed }) )); @@ -606,29 +606,30 @@ pub struct Nfs4ResponseOpenDelegateRead<'a> { named!(nfs4_res_open_ok_delegate_read, 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, 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 } ) )); @@ -652,9 +653,9 @@ pub struct Nfs4ResponseReaddir<'a> { named!(nfs4_res_readdir_entry_do, do_parse!( - cookie: be_u64 + _cookie: be_u64 >> name: nfs4_parse_nfsstring - >> attrs: nfs4_parse_attrs + >> _attrs: nfs4_parse_attrs >> ( Nfs4ResponseReaddirEntry { name: name, }) @@ -669,7 +670,7 @@ named!(nfs4_res_readdir_entry>, named!(nfs4_res_readdir_ok, 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 @@ -687,7 +688,7 @@ named!(nfs4_res_readdir, named!(nfs4_res_create_ok, do_parse!( - change_info: take!(20) + _change_info: take!(20) >> attrs: nfs4_parse_attrbits >> ( attrs ) )); @@ -695,7 +696,7 @@ named!(nfs4_res_create_ok, named!(nfs4_res_create, do_parse!( status: be_u32 - >> attrs: cond!(status == 0, nfs4_res_create_ok) + >> _attrs: cond!(status == 0, nfs4_res_create_ok) >> ( Nfs4ResponseContent::Create(status) ) )); @@ -708,7 +709,7 @@ named!(nfs4_res_setattr_ok, named!(nfs4_res_setattr, do_parse!( status: be_u32 - >> attrs: cond!(status == 0, nfs4_res_setattr_ok) + >> _attrs: cond!(status == 0, nfs4_res_setattr_ok) >> ( Nfs4ResponseContent::SetAttr(status) ) )); @@ -798,8 +799,8 @@ named!(nfs4_res_delegreturn, named!(nfs4_res_setclientid, do_parse!( status: be_u32 - >> client_id: be_u64 - >> verifier: be_u32 + >> _client_id: be_u64 + >> _verifier: be_u32 >> ( Nfs4ResponseContent::SetClientId(status) ) )); @@ -812,7 +813,7 @@ named!(nfs4_res_setclientid_confirm, named!(nfs4_res_commit, do_parse!( status: be_u32 - >> verifier: cond!(status == 0, take!(8)) + >> _verifier: cond!(status == 0, take!(8)) >> ( Nfs4ResponseContent::Commit(status)) )); @@ -903,7 +904,7 @@ named!(pub parse_nfs4_response_compound, 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 { diff --git a/rust/src/smb/dcerpc_records.rs b/rust/src/smb/dcerpc_records.rs index f924d927eb..c2033a7598 100644 --- a/rust/src/smb/dcerpc_records.rs +++ b/rust/src/smb/dcerpc_records.rs @@ -75,8 +75,8 @@ pub struct DceRpcBindIface<'a> { named!(pub parse_dcerpc_bind_iface, 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 @@ -91,8 +91,8 @@ named!(pub parse_dcerpc_bind_iface, named!(pub parse_dcerpc_bind_iface_big, 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 @@ -113,9 +113,9 @@ pub struct DceRpcBindRecord<'a> { named!(pub parse_dcerpc_bind_record, 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) @@ -127,9 +127,9 @@ named!(pub parse_dcerpc_bind_record, named!(pub parse_dcerpc_bind_record_big, 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) @@ -169,9 +169,9 @@ pub struct DceRpcBindAckRecord<'a> { named!(pub parse_dcerpc_bindack_record, 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)) @@ -217,7 +217,7 @@ named!(pub parse_dcerpc_record, 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 { diff --git a/rust/src/smb/ntlmssp_records.rs b/rust/src/smb/ntlmssp_records.rs index 2f6343fad0..d5d8c5125c 100644 --- a/rust/src/smb/ntlmssp_records.rs +++ b/rust/src/smb/ntlmssp_records.rs @@ -58,29 +58,29 @@ pub struct NTLMSSPAuthRecord<'a> { named!(pub parse_ntlm_auth_record, 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) diff --git a/rust/src/smb/smb1_records.rs b/rust/src/smb/smb1_records.rs index 1b620b27d7..084bfa0fb8 100644 --- a/rust/src/smb/smb1_records.rs +++ b/rust/src/smb/smb1_records.rs @@ -48,19 +48,19 @@ pub struct Smb1WriteRequestRecord<'a> { named!(pub parse_smb1_write_request_record, 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, })) ); @@ -68,44 +68,44 @@ named!(pub parse_smb1_write_request_record, named!(pub parse_smb1_write_andx_request_record, 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, 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, })) ); @@ -118,8 +118,8 @@ pub struct Smb1NegotiateProtocolResponseRecord<'a> { named!(pub parse_smb1_negotiate_protocol_response_record_error, do_parse!( - wct: le_u8 - >> bcc: le_u16 + _wct: le_u8 + >> _bcc: le_u16 >> ( Smb1NegotiateProtocolResponseRecord { dialect_idx: 0, server_guid: &[], @@ -128,18 +128,18 @@ named!(pub parse_smb1_negotiate_protocol_response_record_error, 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(&[]), })) ); @@ -157,12 +157,12 @@ pub struct Smb1NegotiateProtocolRecord<'a> { named!(pub parse_smb1_negotiate_protocol_record, 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 })) ); @@ -176,17 +176,17 @@ pub struct Smb1ResponseRecordTreeConnectAndX<'a> { named!(pub parse_smb_connect_tree_andx_response_record, 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 })) ); @@ -205,8 +205,8 @@ pub fn parse_smb_connect_tree_andx_record<'a>(i: &'a[u8], r: &SmbRecord) -> IRes >> path: apply!(smb1_get_string, r, 11 + pwlen as usize) >> service: take_until_and_consume!("\x00") >> (SmbRecordTreeConnectAndX { - path: path, - service: service, + path, + service })) } @@ -230,7 +230,7 @@ named!(pub parse_smb_trans_request_record_pipe, >> fid: take!(2) >> (SmbPipeProtocolRecord { function: fun, - fid: fid, + fid }) ) ); @@ -249,14 +249,14 @@ pub struct SmbRecordTransRequestParams<> { named!(pub parse_smb_trans_request_record_params<(SmbRecordTransRequestParams, Option)>, 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 @@ -267,12 +267,12 @@ named!(pub parse_smb_trans_request_record_params<(SmbRecordTransRequestParams, O >> 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))) ); @@ -357,7 +357,7 @@ pub struct SmbRecordTransResponse<'a> { named!(pub parse_smb_trans_response_error_record, do_parse!( - wct: le_u8 + _wct: le_u8 >> bcc: le_u16 >> (SmbRecordTransResponse { data_cnt:0, @@ -368,25 +368,25 @@ named!(pub parse_smb_trans_response_error_record, named!(pub parse_smb_trans_response_regular_record, 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 })) ); @@ -403,13 +403,13 @@ pub struct SmbRecordSetupAndX<'a> { named!(pub parse_smb_setup_andx_record, 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 })) ); @@ -420,19 +420,19 @@ pub struct SmbResponseRecordSetupAndX<'a> { named!(response_setup_andx_record, 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, do_parse!( - skip1: take!(7) - >> bcc: le_u16 + _skip1: take!(7) + >> _bcc: le_u16 >> (SmbResponseRecordSetupAndX { sec_blob:&[], })) @@ -440,8 +440,8 @@ named!(response_setup_andx_wct3_record, named!(response_setup_andx_error_record, do_parse!( - wct: le_u8 - >> bcc: le_u16 + _wct: le_u8 + >> _bcc: le_u16 >> (SmbResponseRecordSetupAndX { sec_blob: &[], })) @@ -464,9 +464,9 @@ pub struct SmbRequestReadAndXRecord<'a> { named!(pub parse_smb_read_andx_request_record, 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 @@ -475,7 +475,7 @@ named!(pub parse_smb_read_andx_request_record, >> 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 }, })) @@ -489,17 +489,17 @@ pub struct SmbResponseReadAndXRecord<'a> { named!(pub parse_smb_read_andx_response_record, 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 { @@ -516,16 +516,16 @@ pub struct SmbRequestRenameRecord { named!(pub parse_smb_rename_request_record, 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 })) ); @@ -538,14 +538,14 @@ pub struct SmbRequestCreateAndXRecord<'a> { named!(pub parse_smb_create_andx_request_record, 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, @@ -593,7 +593,7 @@ named!(pub parse_trans2_request_data_set_file_info_rename> _reserved: take!(3) - >> root_dir: take!(4) + >> _root_dir: take!(4) >> newname_len: le_u32 >> newname: take!(newname_len) >> (Trans2RecordParamSetFileInfoRename { @@ -614,8 +614,8 @@ named!(pub parse_trans2_request_params_set_path_info> _reserved: take!(4) >> oldname: call!(smb_get_unicode_string) >> (Trans2RecordParamSetPathInfo { - loi:loi, - oldname:oldname, + loi, + oldname }) )); @@ -629,12 +629,12 @@ named!(pub parse_trans2_request_data_set_path_info_rename> _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 }) )); @@ -647,32 +647,32 @@ pub struct SmbRequestTrans2Record<'a> { named!(pub parse_smb_trans2_request_record, 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 })) ); @@ -689,24 +689,24 @@ pub struct SmbResponseCreateAndXRecord<'a> { named!(pub parse_smb_create_andx_response_record, 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), @@ -780,8 +780,8 @@ named!(pub parse_smb_record, >> 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 diff --git a/rust/src/smb/smb2_records.rs b/rust/src/smb/smb2_records.rs index 7b34278cc2..d35a43028d 100644 --- a/rust/src/smb/smb2_records.rs +++ b/rust/src/smb/smb2_records.rs @@ -51,13 +51,13 @@ impl<'a> Smb2Record<'a> { named!(pub parse_smb2_request_record, 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 @@ -70,10 +70,10 @@ named!(pub parse_smb2_request_record, )) >> 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) @@ -97,15 +97,15 @@ pub struct Smb2NegotiateProtocolRequestRecord<'a> { named!(pub parse_smb2_request_negotiate_protocol, 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, @@ -121,21 +121,21 @@ pub struct Smb2NegotiateProtocolResponseRecord<'a> { named!(pub parse_smb2_response_negotiate_protocol, 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, do_parse!( - struct_size: take!(2) - >> skip1: take!(2) + _struct_size: take!(2) + >> _skip1: take!(2) >> (Smb2NegotiateProtocolResponseRecord { dialect: 0, server_guid: &[], @@ -150,14 +150,14 @@ pub struct Smb2SessionSetupRequestRecord<'a> { named!(pub parse_smb2_request_session_setup, 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, @@ -172,8 +172,8 @@ pub struct Smb2TreeConnectRequestRecord<'a> { named!(pub parse_smb2_request_tree_connect, do_parse!( - struct_size: take!(2) - >> offset_length: take!(4) + _struct_size: take!(2) + >> _offset_length: take!(4) >> data: rest >> (Smb2TreeConnectRequestRecord { share_name:data, @@ -187,13 +187,13 @@ pub struct Smb2TreeConnectResponseRecord<> { named!(pub parse_smb2_response_tree_connect, 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 }) )); @@ -207,18 +207,18 @@ pub struct Smb2CreateRequestRecord<'a> { named!(pub parse_smb2_request_create, 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 }) )); @@ -232,15 +232,15 @@ pub struct Smb2IOCtlRequestRecord<'a> { named!(pub parse_smb2_request_ioctl, 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 { @@ -264,7 +264,7 @@ pub struct Smb2IOCtlResponseRecord<'a> { named!(pub parse_smb2_response_ioctl, do_parse!( - skip: take!(2) // structure size + _skip: take!(2) // structure size >> take!(2) // reserved >> func: le_u32 >> guid: take!(16) @@ -293,10 +293,10 @@ pub struct Smb2CloseRequestRecord<'a> { named!(pub parse_smb2_request_close, do_parse!( - skip: take!(8) + _skip: take!(8) >> guid: take!(16) >> (Smb2CloseRequestRecord { - guid:guid, + guid }) )); @@ -307,13 +307,13 @@ pub struct Smb2SetInfoRequestRenameRecord<'a> { named!(pub parse_smb2_request_setinfo_rename, 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 }) )); @@ -327,13 +327,13 @@ pub struct Smb2SetInfoRequestRecord<'a> { named!(pub parse_smb2_request_setinfo, 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 { @@ -355,14 +355,14 @@ pub struct Smb2WriteRequestRecord<'a> { // can be called on incomplete records named!(pub parse_smb2_request_write, 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, @@ -381,14 +381,14 @@ pub struct Smb2ReadRequestRecord<'a> { named!(pub parse_smb2_request_read, 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, @@ -418,10 +418,10 @@ fn parse_smb2_data<'a>(i: &'a[u8], len: u32) // can be called on incomplete records named!(pub parse_smb2_response_read, 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 { @@ -442,20 +442,20 @@ pub struct Smb2CreateResponseRecord<'a> { named!(pub parse_smb2_response_create, 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), @@ -473,9 +473,9 @@ pub struct Smb2WriteResponseRecord<> { named!(pub parse_smb2_response_write, do_parse!( - skip1: take!(4) + _skip1: take!(4) >> wr_cnt: le_u32 - >> skip2: take!(6) + >> _skip2: take!(6) >> (Smb2WriteResponseRecord { wr_cnt : wr_cnt, }) @@ -485,10 +485,10 @@ named!(pub parse_smb2_response_record, 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 @@ -501,11 +501,11 @@ named!(pub parse_smb2_response_record, )) >> 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) diff --git a/rust/src/smb/smb3.rs b/rust/src/smb/smb3.rs index 2d74951f07..f90cddf71e 100644 --- a/rust/src/smb/smb3.rs +++ b/rust/src/smb/smb3.rs @@ -27,16 +27,16 @@ pub struct Smb3TransformRecord<'a> { named!(pub parse_smb3_transform_record, 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, }) ));