rust: fix warnings for unused variables (add _)

rust/src/applayertemplate/parser.rs

@@ -23,10 +23,10 @@ fn parse_len(input: &str) -> Result<u32, std::num::ParseIntError> {
 
 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()
                )

rust/src/dhcp/parser.rs

@@ -120,10 +120,10 @@ named!(pub parse_header<DHCPHeader>,
 
 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,
@@ -139,8 +139,8 @@ named!(pub parse_clientid_option<DHCPOption>,
 
 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{

rust/src/nfs/nfs2_records.rs

@@ -45,10 +45,10 @@ named!(pub parse_nfs2_request_lookup<Nfs2RequestLookup>,
             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<Nfs2RequestRead>,
     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<NfsReplyRead>,
         >>  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<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
             }
         ))
 );

rust/src/nfs/nfs3_records.rs

@@ -114,7 +114,7 @@ named!(pub parse_nfs3_request_remove<Nfs3RequestRemove>,
             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<Nfs3RequestRmdir>,
             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<Nfs3RequestMkdir>,
             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<Nfs3RequestRename>,
             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<Nfs3RequestCommit>,
     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<Nfs3RequestRead>,
     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<Nfs3RequestLookup>,
             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<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,
                 }
            )
         )
@@ -317,11 +317,11 @@ pub struct Nfs3ResponseReaddirplusEntry<'a> {
 
 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
             }
            ))
 );
@@ -336,13 +336,13 @@ named!(pub parse_nfs3_response_readdirplus<Nfs3ResponseReaddirplus>,
     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
         } ))
 );
 

rust/src/nfs/nfs4_records.rs

@@ -139,23 +139,23 @@ pub struct Nfs4RequestSetClientId<'a> {
 
 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)
 ));
 
@@ -171,7 +171,7 @@ named!(nfs4_req_create<Nfs4RequestContent>,
             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<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 )
     )
 );
@@ -265,8 +265,8 @@ named!(nfs4_req_rename<Nfs4RequestContent>,
             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<Nfs4RequestContent>,
     do_parse!(
             filename: nfs4_parse_nfsstring
         >> ( Nfs4RequestContent::Lookup(Nfs4RequestLookup {
-                filename: filename,
+                filename
             })
         ))
 );
@@ -299,9 +299,9 @@ pub struct Nfs4RequestSetAttr<'a> {
 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
             }))
 ));
 
@@ -360,7 +360,7 @@ named!(nfs4_req_read<Nfs4RequestContent>,
 
 named!(nfs4_req_close<Nfs4RequestContent>,
     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<Nfs4RequestContent>,
     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<Nfs4RequestContent>,
 
 named!(nfs4_req_commit<Nfs4RequestContent>,
     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<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
             }
         ))
 ));
@@ -453,13 +453,13 @@ pub struct Nfs4RequestSequence<'a> {
 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
             }
         ))
 ));
@@ -504,12 +504,12 @@ pub struct Nfs4RequestCompoundRecord<'a> {
 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
             })
 ));
 
@@ -550,10 +550,10 @@ named!(nfs4_res_write_ok<Nfs4ResponseWrite>,
     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<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
              } )
 ));
 
@@ -652,9 +653,9 @@ pub struct Nfs4ResponseReaddir<'a> {
 
 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,
             })
@@ -669,7 +670,7 @@ named!(nfs4_res_readdir_entry<Option<Nfs4ResponseReaddirEntry>>,
 
 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
@@ -687,7 +688,7 @@ named!(nfs4_res_readdir<Nfs4ResponseContent>,
 
 named!(nfs4_res_create_ok<Nfs4Attr>,
     do_parse!(
-            change_info: take!(20)
+            _change_info: take!(20)
         >>  attrs: nfs4_parse_attrbits
         >> ( attrs )
 ));
@@ -695,7 +696,7 @@ named!(nfs4_res_create_ok<Nfs4Attr>,
 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) )
 ));
 
@@ -708,7 +709,7 @@ named!(nfs4_res_setattr_ok<Nfs4Attr>,
 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) )
 ));
 
@@ -798,8 +799,8 @@ named!(nfs4_res_delegreturn<Nfs4ResponseContent>,
 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) )
 ));
 
@@ -812,7 +813,7 @@ named!(nfs4_res_setclientid_confirm<Nfs4ResponseContent>,
 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))
 ));
 
@@ -903,7 +904,7 @@ named!(pub parse_nfs4_response_compound<Nfs4ResponseCompoundRecord>,
     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 {

rust/src/smb/dcerpc_records.rs

@@ -75,8 +75,8 @@ pub struct DceRpcBindIface<'a> {
 
 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
@@ -91,8 +91,8 @@ named!(pub parse_dcerpc_bind_iface<DceRpcBindIface>,
 
 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
@@ -113,9 +113,9 @@ pub struct DceRpcBindRecord<'a> {
 
 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)
@@ -127,9 +127,9 @@ named!(pub parse_dcerpc_bind_record<DceRpcBindRecord>,
 
 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)
@@ -169,9 +169,9 @@ pub struct DceRpcBindAckRecord<'a> {
 
 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))
@@ -217,7 +217,7 @@ named!(pub parse_dcerpc_record<DceRpcRecord>,
                 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 {

rust/src/smb/ntlmssp_records.rs

@@ -58,29 +58,29 @@ pub struct NTLMSSPAuthRecord<'a> {
 
 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)

rust/src/smb/smb1_records.rs

@@ -48,19 +48,19 @@ pub struct Smb1WriteRequestRecord<'a> {
 
 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,
             }))
 );
@@ -68,44 +68,44 @@ named!(pub parse_smb1_write_request_record<Smb1WriteRequestRecord>,
 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,
             }))
 );
@@ -118,8 +118,8 @@ pub struct Smb1NegotiateProtocolResponseRecord<'a> {
 
 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: &[],
@@ -128,18 +128,18 @@ named!(pub parse_smb1_negotiate_protocol_response_record_error<Smb1NegotiateProt
 
 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(&[]),
             }))
 );
@@ -157,12 +157,12 @@ pub struct Smb1NegotiateProtocolRecord<'a> {
 
 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
             }))
 );
 
@@ -176,17 +176,17 @@ pub struct Smb1ResponseRecordTreeConnectAndX<'a> {
 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
            }))
 );
 
@@ -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<SmbPipeProtocolRecord>,
         >>  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<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
@@ -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<SmbRecordTransResponse>,
     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<SmbRecordTransResponse>,
 
 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
            }))
 );
 
@@ -403,13 +403,13 @@ pub struct SmbRecordSetupAndX<'a> {
 
 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
            }))
 );
 
@@ -420,19 +420,19 @@ pub struct SmbResponseRecordSetupAndX<'a> {
 
 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:&[],
            }))
@@ -440,8 +440,8 @@ named!(response_setup_andx_wct3_record<SmbResponseRecordSetupAndX>,
 
 named!(response_setup_andx_error_record<SmbResponseRecordSetupAndX>,
     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<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
@@ -475,7 +475,7 @@ named!(pub parse_smb_read_andx_request_record<SmbRequestReadAndXRecord>,
         >>  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<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 {
@@ -516,16 +516,16 @@ pub struct SmbRequestRenameRecord {
 
 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
            }))
 );
 
@@ -538,14 +538,14 @@ pub struct SmbRequestCreateAndXRecord<'a> {
 
 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,
@@ -593,7 +593,7 @@ named!(pub parse_trans2_request_data_set_file_info_rename<Trans2RecordParamSetFi
     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 {
@@ -614,8 +614,8 @@ named!(pub parse_trans2_request_params_set_path_info<Trans2RecordParamSetPathInf
         >>  _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<Trans2RecordParamSetPa
     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
             })
 ));
 
@@ -647,32 +647,32 @@ pub struct SmbRequestTrans2Record<'a> {
 
 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
            }))
 );
 
@@ -689,24 +689,24 @@ pub struct SmbResponseCreateAndXRecord<'a> {
 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),
@@ -780,8 +780,8 @@ named!(pub parse_smb_record<SmbRecord>,
         >>  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

rust/src/smb/smb2_records.rs

@@ -51,13 +51,13 @@ impl<'a> Smb2Record<'a> {
 
 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
@@ -70,10 +70,10 @@ named!(pub parse_smb2_request_record<Smb2Record>,
             ))
         >> 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<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,
@@ -121,21 +121,21 @@ pub struct Smb2NegotiateProtocolResponseRecord<'a> {
 
 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: &[],
@@ -150,14 +150,14 @@ pub struct Smb2SessionSetupRequestRecord<'a> {
 
 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,
@@ -172,8 +172,8 @@ pub struct Smb2TreeConnectRequestRecord<'a> {
 
 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,
@@ -187,13 +187,13 @@ pub struct Smb2TreeConnectResponseRecord<> {
 
 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
             })
 ));
 
@@ -207,18 +207,18 @@ pub struct Smb2CreateRequestRecord<'a> {
 
 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
             })
 ));
 
@@ -232,15 +232,15 @@ pub struct Smb2IOCtlRequestRecord<'a> {
 
 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 {
@@ -264,7 +264,7 @@ pub struct Smb2IOCtlResponseRecord<'a> {
 
 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)
@@ -293,10 +293,10 @@ pub struct Smb2CloseRequestRecord<'a> {
 
 named!(pub parse_smb2_request_close<Smb2CloseRequestRecord>,
     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<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
             })
 ));
 
@@ -327,13 +327,13 @@ pub struct Smb2SetInfoRequestRecord<'a> {
 
 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 {
@@ -355,14 +355,14 @@ pub struct Smb2WriteRequestRecord<'a> {
 // 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,
@@ -381,14 +381,14 @@ pub struct Smb2ReadRequestRecord<'a> {
 
 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,
@@ -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<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 {
@@ -442,20 +442,20 @@ pub struct Smb2CreateResponseRecord<'a> {
 
 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),
@@ -473,9 +473,9 @@ pub struct Smb2WriteResponseRecord<> {
 
 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,
             })
@@ -485,10 +485,10 @@ named!(pub parse_smb2_response_record<Smb2Record>,
     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<Smb2Record>,
             ))
         >> 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)

rust/src/smb/smb3.rs

@@ -27,16 +27,16 @@ pub struct Smb3TransformRecord<'a> {
 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,
             })
 ));