DCE/RPC header - pack type tests

11 files changed, 1057 insertions, 877 deletions

diff --git a/source/include/lib_smb_proto.h b/source/include/lib_smb_proto.h
index 2a19b45afa7..0a9a595805d 100644
--- a/source/include/lib_smb_proto.h
+++ b/source/include/lib_smb_proto.h
@@ -622,48 +622,61 @@ BOOL smb_io_rpc_auth_ntlmssp_chk(char *desc, RPC_AUTH_NTLMSSP_CHK *chk, prs_stru
 
 /*The following definitions come from  rpc_parse/parse_prs.c  */
 
-void prs_debug(prs_struct *ps, int depth, const char *desc, const char *fn_name);
-void prs_debug_out(const prs_struct *ps, char *msg, int level);
-void prs_init(prs_struct *ps, uint32 size, uint8 align,  BOOL io);
-void prs_set_packtype(prs_struct *ps, const uint8 *pack_type);
-void prs_create(prs_struct *ps, char *data, uint32 size, uint8 align, BOOL io);
-BOOL prs_copy(prs_struct *ps, const prs_struct *from);
-BOOL prs_alloc_data(prs_struct *buf, int size);
-BOOL prs_buf_copy(char *copy_into, const prs_struct *buf,
-				uint32 offset, uint32 len);
-void prs_struct_free(prs_struct **buf);
-void prs_free_data(prs_struct *buf);
-BOOL prs_realloc_data(prs_struct *buf, size_t new_size);
-BOOL prs_grow_data(prs_struct *buf, BOOL io, int new_size, BOOL force_grow);
-uint32 prs_buf_len(const prs_struct *buf);
-char *prs_data(const prs_struct *buf, uint32 offset);
-void prs_link(prs_struct *prev, prs_struct *ps, prs_struct *next);
-void prs_align(prs_struct *ps);
-BOOL prs_grow(prs_struct *ps, uint32 new_size);
-BOOL prs_append_data(prs_struct *ps, const char *data, int len);
-BOOL prs_add_data(prs_struct *ps, const char *data, int len);
-BOOL _prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8);
-BOOL _prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16);
-BOOL _prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16]);
-BOOL _prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32);
-BOOL _prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *data8s, int len);
-BOOL _prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len);
-BOOL _prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *data32s, int len);
-BOOL _prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *str);
-BOOL _prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *str);
-BOOL _prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *str);
-BOOL _prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int depth);
-BOOL _prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str);
-BOOL _prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, uint16 max_buf_size);
-BOOL _prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset);
-BOOL _prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
-				uint32 ptr_uint16, uint32 start_offset);
-BOOL _prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset);
-BOOL _prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
-				uint32 ptr_uint32, uint32 data_size);
-int prs_tdb_delete(TDB_CONTEXT *tdb, prs_struct *pk);
-int prs_tdb_store(TDB_CONTEXT *tdb, int flgs, prs_struct *pk, prs_struct *pd);
-void prs_tdb_fetch(TDB_CONTEXT *tdb, prs_struct *pk, prs_struct *pd);
+void prs_debug(prs_struct * ps, int depth, const char *desc,
+	       const char *fn_name);
+void prs_debug_out(const prs_struct * ps, char *msg, int level);
+void prs_init(prs_struct * ps, uint32 size, uint8 align, BOOL io);
+void prs_set_packtype(prs_struct * ps, const uint8 * pack_type);
+void prs_create(prs_struct * ps, char *data, uint32 size, uint8 align,
+		BOOL io);
+BOOL prs_copy(prs_struct * ps, const prs_struct * from);
+BOOL prs_alloc_data(prs_struct * buf, int size);
+BOOL prs_buf_copy(char *copy_into, const prs_struct * buf,
+		  uint32 offset, uint32 len);
+void prs_struct_free(prs_struct ** buf);
+void prs_free_data(prs_struct * buf);
+BOOL prs_realloc_data(prs_struct * buf, size_t new_size);
+BOOL prs_grow_data(prs_struct * buf, BOOL io, int new_size, BOOL force_grow);
+uint32 prs_buf_len(const prs_struct * buf);
+char *prs_data(const prs_struct * buf, uint32 offset);
+void prs_link(prs_struct * prev, prs_struct * ps, prs_struct * next);
+void prs_align(prs_struct * ps);
+BOOL prs_grow(prs_struct * ps, uint32 new_size);
+BOOL prs_append_data(prs_struct * ps, const char *data, int len);
+BOOL prs_add_data(prs_struct * ps, const char *data, int len);
+BOOL _prs_uint8(char *name, prs_struct * ps, int depth, uint8 * data8);
+BOOL _prs_uint16(char *name, prs_struct * ps, int depth, uint16 * data16);
+BOOL _prs_hash1(prs_struct * ps, uint32 offset, uint8 sess_key[16]);
+BOOL _prs_uint32(char *name, prs_struct * ps, int depth, uint32 * data32);
+BOOL _prs_uint8s(BOOL charmode, char *name, prs_struct * ps, int depth,
+		 uint8 * data8s, int len);
+BOOL _prs_uint16s(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  uint16 * data16s, int len);
+BOOL _prs_uint32s(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  uint32 * data32s, int len);
+BOOL _prs_buffer2(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  BUFFER2 * str);
+BOOL _prs_string2(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  STRING2 * str);
+BOOL _prs_unistr2(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  UNISTR2 * str);
+BOOL _prs_unistr3(BOOL charmode, char *name, UNISTR3 * str, prs_struct * ps,
+		  int depth);
+BOOL _prs_unistr(char *name, prs_struct * ps, int depth, UNISTR * str);
+BOOL _prs_string(char *name, prs_struct * ps, int depth, char *str,
+		 uint16 len, uint16 max_buf_size);
+BOOL _prs_uint16_pre(char *name, prs_struct * ps, int depth, uint16 * data16,
+		     uint32 * offset);
+BOOL _prs_uint16_post(char *name, prs_struct * ps, int depth, uint16 * data16,
+		      uint32 ptr_uint16, uint32 start_offset);
+BOOL _prs_uint32_pre(char *name, prs_struct * ps, int depth, uint32 * data32,
+		     uint32 * offset);
+BOOL _prs_uint32_post(char *name, prs_struct * ps, int depth, uint32 * data32,
+		      uint32 ptr_uint32, uint32 data_size);
+int prs_tdb_delete(TDB_CONTEXT * tdb, prs_struct * pk);
+int prs_tdb_store(TDB_CONTEXT * tdb, int flgs, prs_struct * pk,
+		  prs_struct * pd);
+void prs_tdb_fetch(TDB_CONTEXT * tdb, prs_struct * pk, prs_struct * pd);
 
 /*The following definitions come from  rpc_parse/parse_vuid.c  */
 
diff --git a/source/include/proto.h b/source/include/proto.h
index 5dde2fb45a2..bf94f976a3b 100644
--- a/source/include/proto.h
+++ b/source/include/proto.h
@@ -3144,87 +3144,109 @@ BOOL smb_io_rpc_auth_ntlmssp_chk(char *desc, RPC_AUTH_NTLMSSP_CHK *chk, prs_stru
 
 /*The following definitions come from  rpc_parse/parse_prs.c  */
 
-void prs_debug(prs_struct *ps, int depth, const char *desc, const char *fn_name);
-void prs_debug_out(const prs_struct *ps, char *msg, int level);
-void prs_init(prs_struct *ps, uint32 size, uint8 align,  BOOL io);
-void prs_set_packtype(prs_struct *ps, const uint8 *pack_type);
-void prs_create(prs_struct *ps, char *data, uint32 size, uint8 align, BOOL io);
-BOOL prs_copy(prs_struct *ps, const prs_struct *from);
-BOOL prs_alloc_data(prs_struct *buf, int size);
-BOOL prs_buf_copy(char *copy_into, const prs_struct *buf,
-				uint32 offset, uint32 len);
-void prs_struct_free(prs_struct **buf);
-void prs_free_data(prs_struct *buf);
-BOOL prs_realloc_data(prs_struct *buf, size_t new_size);
-BOOL prs_grow_data(prs_struct *buf, BOOL io, int new_size, BOOL force_grow);
-uint32 prs_buf_len(const prs_struct *buf);
-char *prs_data(const prs_struct *buf, uint32 offset);
-void prs_link(prs_struct *prev, prs_struct *ps, prs_struct *next);
-void prs_align(prs_struct *ps);
-BOOL prs_grow(prs_struct *ps, uint32 new_size);
-BOOL prs_append_data(prs_struct *ps, const char *data, int len);
-BOOL prs_add_data(prs_struct *ps, const char *data, int len);
-BOOL _prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8);
-BOOL _prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16);
-BOOL _prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16]);
-BOOL _prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32);
-BOOL _prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *data8s, int len);
-BOOL _prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len);
-BOOL _prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *data32s, int len);
-BOOL _prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *str);
-BOOL _prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *str);
-BOOL _prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *str);
-BOOL _prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int depth);
-BOOL _prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str);
-BOOL _prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, uint16 max_buf_size);
-BOOL _prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset);
-BOOL _prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
-				uint32 ptr_uint16, uint32 start_offset);
-BOOL _prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset);
-BOOL _prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
-				uint32 ptr_uint32, uint32 data_size);
-int prs_tdb_delete(TDB_CONTEXT *tdb, prs_struct *pk);
-int prs_tdb_store(TDB_CONTEXT *tdb, int flgs, prs_struct *pk, prs_struct *pd);
-void prs_tdb_fetch(TDB_CONTEXT *tdb, prs_struct *pk, prs_struct *pd);
+void prs_debug(prs_struct * ps, int depth, const char *desc,
+	       const char *fn_name);
+void prs_debug_out(const prs_struct * ps, char *msg, int level);
+void prs_init(prs_struct * ps, uint32 size, uint8 align, BOOL io);
+void prs_set_packtype(prs_struct * ps, const uint8 * pack_type);
+void prs_create(prs_struct * ps, char *data, uint32 size, uint8 align,
+		BOOL io);
+BOOL prs_copy(prs_struct * ps, const prs_struct * from);
+BOOL prs_alloc_data(prs_struct * buf, int size);
+BOOL prs_buf_copy(char *copy_into, const prs_struct * buf,
+		  uint32 offset, uint32 len);
+void prs_struct_free(prs_struct ** buf);
+void prs_free_data(prs_struct * buf);
+BOOL prs_realloc_data(prs_struct * buf, size_t new_size);
+BOOL prs_grow_data(prs_struct * buf, BOOL io, int new_size, BOOL force_grow);
+uint32 prs_buf_len(const prs_struct * buf);
+char *prs_data(const prs_struct * buf, uint32 offset);
+void prs_link(prs_struct * prev, prs_struct * ps, prs_struct * next);
+void prs_align(prs_struct * ps);
+BOOL prs_grow(prs_struct * ps, uint32 new_size);
+BOOL prs_append_data(prs_struct * ps, const char *data, int len);
+BOOL prs_add_data(prs_struct * ps, const char *data, int len);
+BOOL _prs_uint8(char *name, prs_struct * ps, int depth, uint8 * data8);
+BOOL _prs_uint16(char *name, prs_struct * ps, int depth, uint16 * data16);
+BOOL _prs_hash1(prs_struct * ps, uint32 offset, uint8 sess_key[16]);
+BOOL _prs_uint32(char *name, prs_struct * ps, int depth, uint32 * data32);
+BOOL _prs_uint8s(BOOL charmode, char *name, prs_struct * ps, int depth,
+		 uint8 * data8s, int len);
+BOOL _prs_uint16s(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  uint16 * data16s, int len);
+BOOL _prs_uint32s(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  uint32 * data32s, int len);
+BOOL _prs_buffer2(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  BUFFER2 * str);
+BOOL _prs_string2(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  STRING2 * str);
+BOOL _prs_unistr2(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  UNISTR2 * str);
+BOOL _prs_unistr3(BOOL charmode, char *name, UNISTR3 * str, prs_struct * ps,
+		  int depth);
+BOOL _prs_unistr(char *name, prs_struct * ps, int depth, UNISTR * str);
+BOOL _prs_string(char *name, prs_struct * ps, int depth, char *str,
+		 uint16 len, uint16 max_buf_size);
+BOOL _prs_uint16_pre(char *name, prs_struct * ps, int depth, uint16 * data16,
+		     uint32 * offset);
+BOOL _prs_uint16_post(char *name, prs_struct * ps, int depth, uint16 * data16,
+		      uint32 ptr_uint16, uint32 start_offset);
+BOOL _prs_uint32_pre(char *name, prs_struct * ps, int depth, uint32 * data32,
+		     uint32 * offset);
+BOOL _prs_uint32_post(char *name, prs_struct * ps, int depth, uint32 * data32,
+		      uint32 ptr_uint32, uint32 data_size);
+int prs_tdb_delete(TDB_CONTEXT * tdb, prs_struct * pk);
+int prs_tdb_store(TDB_CONTEXT * tdb, int flgs, prs_struct * pk,
+		  prs_struct * pd);
+void prs_tdb_fetch(TDB_CONTEXT * tdb, prs_struct * pk, prs_struct * pd);
 
 /*The following definitions come from  rpc_parse/parse_rpc.c  */
 
-BOOL make_rpc_hdr(RPC_HDR *hdr, enum RPC_PKT_TYPE pkt_type, uint8 flags,
-				uint32 call_id, int data_len, int auth_len);
-BOOL smb_io_rpc_hdr(char *desc,  RPC_HDR *rpc, prs_struct *ps, int depth);
-BOOL is_complete_pdu(prs_struct *ps);
-BOOL smb_io_rpc_hdr_nack(char *desc,  RPC_HDR_NACK *rpc, prs_struct *ps, int depth);
-BOOL smb_io_rpc_hdr_fault(char *desc,  RPC_HDR_FAULT *rpc, prs_struct *ps, int depth);
-BOOL make_rpc_hdr_rb(RPC_HDR_RB *rpc, 
-				uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid,
-				uint32 num_elements, uint16 context_id, uint8 num_syntaxes,
-				RPC_IFACE *abstract, RPC_IFACE *transfer);
-BOOL smb_io_rpc_hdr_rb(char *desc,  RPC_HDR_RB *rpc, prs_struct *ps, int depth);
-BOOL make_rpc_hdr_ba(RPC_HDR_BA *rpc, 
-				uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid,
-				const char *pipe_addr,
-				uint8 num_results, uint16 result, uint16 reason,
-				RPC_IFACE *transfer);
-BOOL smb_io_rpc_hdr_ba(char *desc,  RPC_HDR_BA *rpc, prs_struct *ps, int depth);
-BOOL make_rpc_hdr_req(RPC_HDR_REQ *hdr, uint32 alloc_hint, uint16 vuid,
-				uint16 opnum);
-BOOL smb_io_rpc_hdr_req(char *desc,  RPC_HDR_REQ *rpc, prs_struct *ps, int depth);
-BOOL smb_io_rpc_hdr_resp(char *desc,  RPC_HDR_RESP *rpc, prs_struct *ps, int depth);
-BOOL make_rpc_hdr_autha(RPC_HDR_AUTHA *rai,
-				uint16 max_tsize, uint16 max_rsize,
-				uint8 auth_type, uint8 auth_level,
-				uint8 stub_type_len);
-BOOL smb_io_rpc_hdr_autha(char *desc, RPC_HDR_AUTHA *rai, prs_struct *ps, int depth);
-BOOL make_rpc_hdr_auth(RPC_HDR_AUTH *rai,
-				uint8 auth_type, uint8 auth_level,
-				uint8 stub_type_len,
-				uint32 ptr);
-BOOL smb_io_rpc_hdr_auth(char *desc, RPC_HDR_AUTH *rai, prs_struct *ps, int depth);
-BOOL make_rpc_auth_verifier(RPC_AUTH_VERIFIER *rav,
-				char *signature, uint32 msg_type);
-BOOL smb_io_rpc_auth_verifier(char *desc, RPC_AUTH_VERIFIER *rav, prs_struct *ps, int depth);
-BOOL rpc_auth_verifier_chk(RPC_AUTH_VERIFIER *rav,
-				char *signature, uint32 msg_type);
+BOOL make_rpc_hdr(RPC_HDR * hdr, enum RPC_PKT_TYPE pkt_type, uint8 flags,
+		  uint32 call_id, int frag_len, int auth_len);
+BOOL smb_io_rpc_hdr(char *desc, RPC_HDR * rpc, prs_struct * ps, int depth);
+BOOL is_complete_pdu(prs_struct * ps);
+BOOL smb_io_rpc_hdr_nack(char *desc, RPC_HDR_NACK * rpc, prs_struct * ps,
+			 int depth);
+BOOL smb_io_rpc_hdr_fault(char *desc, RPC_HDR_FAULT * rpc, prs_struct * ps,
+			  int depth);
+BOOL make_rpc_hdr_rb(RPC_HDR_RB * rpc,
+		     uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid,
+		     uint32 num_elements, uint16 context_id,
+		     uint8 num_syntaxes, RPC_IFACE * abstract,
+		     RPC_IFACE * transfer);
+BOOL smb_io_rpc_hdr_rb(char *desc, RPC_HDR_RB * rpc, prs_struct * ps,
+		       int depth);
+BOOL make_rpc_hdr_ba(RPC_HDR_BA * rpc,
+		     uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid,
+		     const char *pipe_addr,
+		     uint8 num_results, uint16 result, uint16 reason,
+		     RPC_IFACE * transfer);
+BOOL smb_io_rpc_hdr_ba(char *desc, RPC_HDR_BA * rpc, prs_struct * ps,
+		       int depth);
+BOOL make_rpc_hdr_req(RPC_HDR_REQ * hdr, uint32 alloc_hint, uint16 vuid,
+		      uint16 opnum);
+BOOL smb_io_rpc_hdr_req(char *desc, RPC_HDR_REQ * rpc, prs_struct * ps,
+			int depth);
+BOOL smb_io_rpc_hdr_resp(char *desc, RPC_HDR_RESP * rpc, prs_struct * ps,
+			 int depth);
+BOOL make_rpc_hdr_autha(RPC_HDR_AUTHA * rai,
+			uint16 max_tsize, uint16 max_rsize,
+			uint8 auth_type, uint8 auth_level,
+			uint8 stub_type_len);
+BOOL smb_io_rpc_hdr_autha(char *desc, RPC_HDR_AUTHA * rai, prs_struct * ps,
+			  int depth);
+BOOL make_rpc_hdr_auth(RPC_HDR_AUTH * rai,
+		       uint8 auth_type, uint8 auth_level,
+		       uint8 stub_type_len, uint32 ptr);
+BOOL smb_io_rpc_hdr_auth(char *desc, RPC_HDR_AUTH * rai, prs_struct * ps,
+			 int depth);
+BOOL make_rpc_auth_verifier(RPC_AUTH_VERIFIER * rav,
+			    char *signature, uint32 msg_type);
+BOOL smb_io_rpc_auth_verifier(char *desc, RPC_AUTH_VERIFIER * rav,
+			      prs_struct * ps, int depth);
+BOOL rpc_auth_verifier_chk(RPC_AUTH_VERIFIER * rav,
+			   char *signature, uint32 msg_type);
 
 /*The following definitions come from  rpc_parse/parse_sec.c  */
 
@@ -3542,10 +3564,6 @@ void display_sam_disp_info_ctr(FILE *out_hnd, enum action_type action,
 
 /*The following definitions come from  rpcclient/display_sec.c  */
 
-char *get_sec_mask_str(uint32 type);
-void display_sec_access(FILE *out_hnd, enum action_type action, SEC_ACCESS *const info);
-void display_sec_ace(FILE *out_hnd, enum action_type action, SEC_ACE *const ace);
-void display_sec_acl(FILE *out_hnd, enum action_type action, SEC_ACL *const sec_acl);
 void display_sec_desc(FILE *out_hnd, enum action_type action, SEC_DESC *const sec);
 
 /*The following definitions come from  rpcclient/display_spool.c  */
@@ -3699,6 +3717,10 @@ int main(int argc, char *argv[]);
 char *complete_svcenum(char *text, int state);
 void add_svc_commands(void);
 
+/*The following definitions come from  samrd/samr_util.c  */
+
+uint32 samr_make_usr_obj_sd(SEC_DESC_BUF *buf, DOM_SID *usr_sid);
+
 /*The following definitions come from  samrd/samrd.c  */
 
 msrpc_service_fns *get_service_fns(void);
diff --git a/source/include/rpc_dce.h b/source/include/rpc_dce.h
index 2f996efd3e8..50089511555 100644
--- a/source/include/rpc_dce.h
+++ b/source/include/rpc_dce.h
@@ -45,10 +45,23 @@ enum RPC_PKT_TYPE
 #define RPC_FLG_NOCALL 0x20
 
 
+/*
+ * Actual structure of a DCE UUID
+ */
+
+typedef struct rpc_uuid
+{
+  uint32 time_low;
+  uint16 time_mid;
+  uint16 time_hi_and_version;
+  uint8 remaining[8];
+} RPC_UUID;
+
+
 /* RPC_IFACE */
 typedef struct rpc_iface_info
 {
-  uint8 data[16];    /* 16 bytes of rpc interface identification */
+  RPC_UUID uuid;    /* 16 bytes of rpc interface identification */
   uint32 version;    /* the interface version number */
 
 } RPC_IFACE;
diff --git a/source/include/rpc_parse_proto.h b/source/include/rpc_parse_proto.h
index fe2df3aeefd..e9bd5044dd0 100644
--- a/source/include/rpc_parse_proto.h
+++ b/source/include/rpc_parse_proto.h
@@ -266,42 +266,51 @@ BOOL reg_io_r_shutdown(char *desc,  REG_R_SHUTDOWN *r_q, prs_struct *ps, int dep
 
 /*The following definitions come from  rpc_parse/parse_rpc.c  */
 
-BOOL make_rpc_hdr(RPC_HDR *hdr, enum RPC_PKT_TYPE pkt_type, uint8 flags,
-				uint32 call_id, int data_len, int auth_len);
-BOOL smb_io_rpc_hdr(char *desc,  RPC_HDR *rpc, prs_struct *ps, int depth);
-BOOL is_complete_pdu(prs_struct *ps);
-BOOL smb_io_rpc_hdr_nack(char *desc,  RPC_HDR_NACK *rpc, prs_struct *ps, int depth);
-BOOL smb_io_rpc_hdr_fault(char *desc,  RPC_HDR_FAULT *rpc, prs_struct *ps, int depth);
-BOOL make_rpc_hdr_rb(RPC_HDR_RB *rpc, 
-				uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid,
-				uint32 num_elements, uint16 context_id, uint8 num_syntaxes,
-				RPC_IFACE *abstract, RPC_IFACE *transfer);
-BOOL smb_io_rpc_hdr_rb(char *desc,  RPC_HDR_RB *rpc, prs_struct *ps, int depth);
-BOOL make_rpc_hdr_ba(RPC_HDR_BA *rpc, 
-				uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid,
-				const char *pipe_addr,
-				uint8 num_results, uint16 result, uint16 reason,
-				RPC_IFACE *transfer);
-BOOL smb_io_rpc_hdr_ba(char *desc,  RPC_HDR_BA *rpc, prs_struct *ps, int depth);
-BOOL make_rpc_hdr_req(RPC_HDR_REQ *hdr, uint32 alloc_hint, uint16 vuid,
-				uint16 opnum);
-BOOL smb_io_rpc_hdr_req(char *desc,  RPC_HDR_REQ *rpc, prs_struct *ps, int depth);
-BOOL smb_io_rpc_hdr_resp(char *desc,  RPC_HDR_RESP *rpc, prs_struct *ps, int depth);
-BOOL make_rpc_hdr_autha(RPC_HDR_AUTHA *rai,
-				uint16 max_tsize, uint16 max_rsize,
-				uint8 auth_type, uint8 auth_level,
-				uint8 stub_type_len);
-BOOL smb_io_rpc_hdr_autha(char *desc, RPC_HDR_AUTHA *rai, prs_struct *ps, int depth);
-BOOL make_rpc_hdr_auth(RPC_HDR_AUTH *rai,
-				uint8 auth_type, uint8 auth_level,
-				uint8 stub_type_len,
-				uint32 ptr);
-BOOL smb_io_rpc_hdr_auth(char *desc, RPC_HDR_AUTH *rai, prs_struct *ps, int depth);
-BOOL make_rpc_auth_verifier(RPC_AUTH_VERIFIER *rav,
-				char *signature, uint32 msg_type);
-BOOL smb_io_rpc_auth_verifier(char *desc, RPC_AUTH_VERIFIER *rav, prs_struct *ps, int depth);
-BOOL rpc_auth_verifier_chk(RPC_AUTH_VERIFIER *rav,
-				char *signature, uint32 msg_type);
+BOOL make_rpc_hdr(RPC_HDR * hdr, enum RPC_PKT_TYPE pkt_type, uint8 flags,
+		  uint32 call_id, int frag_len, int auth_len);
+BOOL smb_io_rpc_hdr(char *desc, RPC_HDR * rpc, prs_struct * ps, int depth);
+BOOL is_complete_pdu(prs_struct * ps);
+BOOL smb_io_rpc_hdr_nack(char *desc, RPC_HDR_NACK * rpc, prs_struct * ps,
+			 int depth);
+BOOL smb_io_rpc_hdr_fault(char *desc, RPC_HDR_FAULT * rpc, prs_struct * ps,
+			  int depth);
+BOOL make_rpc_hdr_rb(RPC_HDR_RB * rpc,
+		     uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid,
+		     uint32 num_elements, uint16 context_id,
+		     uint8 num_syntaxes, RPC_IFACE * abstract,
+		     RPC_IFACE * transfer);
+BOOL smb_io_rpc_hdr_rb(char *desc, RPC_HDR_RB * rpc, prs_struct * ps,
+		       int depth);
+BOOL make_rpc_hdr_ba(RPC_HDR_BA * rpc,
+		     uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid,
+		     const char *pipe_addr,
+		     uint8 num_results, uint16 result, uint16 reason,
+		     RPC_IFACE * transfer);
+BOOL smb_io_rpc_hdr_ba(char *desc, RPC_HDR_BA * rpc, prs_struct * ps,
+		       int depth);
+BOOL make_rpc_hdr_req(RPC_HDR_REQ * hdr, uint32 alloc_hint, uint16 vuid,
+		      uint16 opnum);
+BOOL smb_io_rpc_hdr_req(char *desc, RPC_HDR_REQ * rpc, prs_struct * ps,
+			int depth);
+BOOL smb_io_rpc_hdr_resp(char *desc, RPC_HDR_RESP * rpc, prs_struct * ps,
+			 int depth);
+BOOL make_rpc_hdr_autha(RPC_HDR_AUTHA * rai,
+			uint16 max_tsize, uint16 max_rsize,
+			uint8 auth_type, uint8 auth_level,
+			uint8 stub_type_len);
+BOOL smb_io_rpc_hdr_autha(char *desc, RPC_HDR_AUTHA * rai, prs_struct * ps,
+			  int depth);
+BOOL make_rpc_hdr_auth(RPC_HDR_AUTH * rai,
+		       uint8 auth_type, uint8 auth_level,
+		       uint8 stub_type_len, uint32 ptr);
+BOOL smb_io_rpc_hdr_auth(char *desc, RPC_HDR_AUTH * rai, prs_struct * ps,
+			 int depth);
+BOOL make_rpc_auth_verifier(RPC_AUTH_VERIFIER * rav,
+			    char *signature, uint32 msg_type);
+BOOL smb_io_rpc_auth_verifier(char *desc, RPC_AUTH_VERIFIER * rav,
+			      prs_struct * ps, int depth);
+BOOL rpc_auth_verifier_chk(RPC_AUTH_VERIFIER * rav,
+			   char *signature, uint32 msg_type);
 
 /*The following definitions come from  rpc_parse/parse_samr.c  */
 
@@ -437,14 +446,16 @@ BOOL make_samr_r_query_usergroups(SAMR_R_QUERY_USERGROUPS *r_u,
 		uint32 num_gids, DOM_GID *gid, uint32 status);
 BOOL samr_io_gids(char *desc, uint32 *num_gids, DOM_GID **gid, prs_struct *ps, int depth);
 BOOL samr_io_r_query_usergroups(char *desc, SAMR_R_QUERY_USERGROUPS *r_u, prs_struct *ps, int depth);
-BOOL make_samr_q_enum_domains(SAMR_Q_ENUM_DOMAINS *q_e, POLICY_HND *pol,
-				uint32 start_idx, uint32 size);
+BOOL make_samr_q_enum_domains(SAMR_Q_ENUM_DOMAINS *q_e,
+			      const POLICY_HND *pol,
+			      uint32 start_idx, uint32 size);
 BOOL samr_io_q_enum_domains(char *desc, SAMR_Q_ENUM_DOMAINS *q_e, prs_struct *ps, int depth);
 BOOL make_samr_r_enum_domains(SAMR_R_ENUM_DOMAINS *r_u,
 		uint32 next_idx, uint32 num_sam_entries);
 BOOL samr_io_r_enum_domains(char *desc, SAMR_R_ENUM_DOMAINS *r_u, prs_struct *ps, int depth);
-BOOL make_samr_q_enum_dom_groups(SAMR_Q_ENUM_DOM_GROUPS *q_e, POLICY_HND *pol,
-				uint32 start_idx, uint32 size);
+BOOL make_samr_q_enum_dom_groups(SAMR_Q_ENUM_DOM_GROUPS *q_e,
+				 const POLICY_HND *pol,
+				 uint32 start_idx, uint32 size);
 BOOL samr_io_q_enum_dom_groups(char *desc, SAMR_Q_ENUM_DOM_GROUPS *q_e, prs_struct *ps, int depth);
 BOOL make_samr_r_enum_dom_groups(SAMR_R_ENUM_DOM_GROUPS *r_u,
 		uint32 next_idx, uint32 num_sam_entries);
@@ -460,19 +471,20 @@ BOOL make_samr_alias_info3(ALIAS_INFO3 *al3, const char *acct_desc);
 BOOL samr_io_alias_info3(char *desc,  ALIAS_INFO3 *al3, prs_struct *ps, int depth);
 BOOL samr_alias_info_ctr(char *desc,  ALIAS_INFO_CTR *ctr, prs_struct *ps, int depth);
 BOOL make_samr_q_query_aliasinfo(SAMR_Q_QUERY_ALIASINFO *q_e,
-				POLICY_HND *pol,
-				uint16 switch_level);
+				 const POLICY_HND *pol, uint16 switch_level);
 BOOL samr_io_q_query_aliasinfo(char *desc,  SAMR_Q_QUERY_ALIASINFO *q_e, prs_struct *ps, int depth);
-BOOL make_samr_r_query_aliasinfo(SAMR_R_QUERY_ALIASINFO *r_u, ALIAS_INFO_CTR *ctr,
-		uint32 status);
+BOOL make_samr_r_query_aliasinfo(SAMR_R_QUERY_ALIASINFO *r_u,
+				 ALIAS_INFO_CTR *ctr, uint32 status);
 BOOL samr_io_r_query_aliasinfo(char *desc,  SAMR_R_QUERY_ALIASINFO *r_u, prs_struct *ps, int depth);
-BOOL make_samr_q_set_aliasinfo(SAMR_Q_SET_ALIASINFO *q_u, POLICY_HND *hnd,
-				ALIAS_INFO_CTR *ctr);
+BOOL make_samr_q_set_aliasinfo(SAMR_Q_SET_ALIASINFO *q_u,
+			       const POLICY_HND *hnd,
+			       ALIAS_INFO_CTR *ctr);
 BOOL samr_io_q_set_aliasinfo(char *desc,  SAMR_Q_SET_ALIASINFO *q_u, prs_struct *ps, int depth);
 BOOL samr_io_r_set_aliasinfo(char *desc,  SAMR_R_SET_ALIASINFO *r_u, prs_struct *ps, int depth);
 BOOL make_samr_q_query_useraliases(SAMR_Q_QUERY_USERALIASES *q_u,
-				const POLICY_HND *hnd,
-				uint32 *ptr_sid, DOM_SID2 *sid);
+				   const POLICY_HND *hnd,
+				   uint32  num_sids,
+				   uint32 *ptr_sid, DOM_SID2 *sid);
 BOOL samr_io_q_query_useraliases(char *desc,  SAMR_Q_QUERY_USERALIASES *q_u, prs_struct *ps, int depth);
 void samr_free_q_query_useraliases(SAMR_Q_QUERY_USERALIASES *q_u);
 BOOL make_samr_r_query_useraliases(SAMR_R_QUERY_USERALIASES *r_u,
diff --git a/source/include/winbindd_proto.h b/source/include/winbindd_proto.h
index 0ad5fd1746b..7aa753fc626 100644
--- a/source/include/winbindd_proto.h
+++ b/source/include/winbindd_proto.h
@@ -2053,87 +2053,109 @@ BOOL smb_io_rpc_auth_ntlmssp_chk(char *desc, RPC_AUTH_NTLMSSP_CHK *chk, prs_stru
 
 /*The following definitions come from  rpc_parse/parse_prs.c  */
 
-void prs_debug(prs_struct *ps, int depth, const char *desc, const char *fn_name);
-void prs_debug_out(const prs_struct *ps, char *msg, int level);
-void prs_init(prs_struct *ps, uint32 size, uint8 align,  BOOL io);
-void prs_set_packtype(prs_struct *ps, const uint8 *pack_type);
-void prs_create(prs_struct *ps, char *data, uint32 size, uint8 align, BOOL io);
-BOOL prs_copy(prs_struct *ps, const prs_struct *from);
-BOOL prs_alloc_data(prs_struct *buf, int size);
-BOOL prs_buf_copy(char *copy_into, const prs_struct *buf,
-				uint32 offset, uint32 len);
-void prs_struct_free(prs_struct **buf);
-void prs_free_data(prs_struct *buf);
-BOOL prs_realloc_data(prs_struct *buf, size_t new_size);
-BOOL prs_grow_data(prs_struct *buf, BOOL io, int new_size, BOOL force_grow);
-uint32 prs_buf_len(const prs_struct *buf);
-char *prs_data(const prs_struct *buf, uint32 offset);
-void prs_link(prs_struct *prev, prs_struct *ps, prs_struct *next);
-void prs_align(prs_struct *ps);
-BOOL prs_grow(prs_struct *ps, uint32 new_size);
-BOOL prs_append_data(prs_struct *ps, const char *data, int len);
-BOOL prs_add_data(prs_struct *ps, const char *data, int len);
-BOOL _prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8);
-BOOL _prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16);
-BOOL _prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16]);
-BOOL _prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32);
-BOOL _prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *data8s, int len);
-BOOL _prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len);
-BOOL _prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *data32s, int len);
-BOOL _prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *str);
-BOOL _prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *str);
-BOOL _prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *str);
-BOOL _prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int depth);
-BOOL _prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str);
-BOOL _prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, uint16 max_buf_size);
-BOOL _prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset);
-BOOL _prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
-				uint32 ptr_uint16, uint32 start_offset);
-BOOL _prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset);
-BOOL _prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
-				uint32 ptr_uint32, uint32 data_size);
-int prs_tdb_delete(TDB_CONTEXT *tdb, prs_struct *pk);
-int prs_tdb_store(TDB_CONTEXT *tdb, int flgs, prs_struct *pk, prs_struct *pd);
-void prs_tdb_fetch(TDB_CONTEXT *tdb, prs_struct *pk, prs_struct *pd);
+void prs_debug(prs_struct * ps, int depth, const char *desc,
+	       const char *fn_name);
+void prs_debug_out(const prs_struct * ps, char *msg, int level);
+void prs_init(prs_struct * ps, uint32 size, uint8 align, BOOL io);
+void prs_set_packtype(prs_struct * ps, const uint8 * pack_type);
+void prs_create(prs_struct * ps, char *data, uint32 size, uint8 align,
+		BOOL io);
+BOOL prs_copy(prs_struct * ps, const prs_struct * from);
+BOOL prs_alloc_data(prs_struct * buf, int size);
+BOOL prs_buf_copy(char *copy_into, const prs_struct * buf,
+		  uint32 offset, uint32 len);
+void prs_struct_free(prs_struct ** buf);
+void prs_free_data(prs_struct * buf);
+BOOL prs_realloc_data(prs_struct * buf, size_t new_size);
+BOOL prs_grow_data(prs_struct * buf, BOOL io, int new_size, BOOL force_grow);
+uint32 prs_buf_len(const prs_struct * buf);
+char *prs_data(const prs_struct * buf, uint32 offset);
+void prs_link(prs_struct * prev, prs_struct * ps, prs_struct * next);
+void prs_align(prs_struct * ps);
+BOOL prs_grow(prs_struct * ps, uint32 new_size);
+BOOL prs_append_data(prs_struct * ps, const char *data, int len);
+BOOL prs_add_data(prs_struct * ps, const char *data, int len);
+BOOL _prs_uint8(char *name, prs_struct * ps, int depth, uint8 * data8);
+BOOL _prs_uint16(char *name, prs_struct * ps, int depth, uint16 * data16);
+BOOL _prs_hash1(prs_struct * ps, uint32 offset, uint8 sess_key[16]);
+BOOL _prs_uint32(char *name, prs_struct * ps, int depth, uint32 * data32);
+BOOL _prs_uint8s(BOOL charmode, char *name, prs_struct * ps, int depth,
+		 uint8 * data8s, int len);
+BOOL _prs_uint16s(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  uint16 * data16s, int len);
+BOOL _prs_uint32s(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  uint32 * data32s, int len);
+BOOL _prs_buffer2(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  BUFFER2 * str);
+BOOL _prs_string2(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  STRING2 * str);
+BOOL _prs_unistr2(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  UNISTR2 * str);
+BOOL _prs_unistr3(BOOL charmode, char *name, UNISTR3 * str, prs_struct * ps,
+		  int depth);
+BOOL _prs_unistr(char *name, prs_struct * ps, int depth, UNISTR * str);
+BOOL _prs_string(char *name, prs_struct * ps, int depth, char *str,
+		 uint16 len, uint16 max_buf_size);
+BOOL _prs_uint16_pre(char *name, prs_struct * ps, int depth, uint16 * data16,
+		     uint32 * offset);
+BOOL _prs_uint16_post(char *name, prs_struct * ps, int depth, uint16 * data16,
+		      uint32 ptr_uint16, uint32 start_offset);
+BOOL _prs_uint32_pre(char *name, prs_struct * ps, int depth, uint32 * data32,
+		     uint32 * offset);
+BOOL _prs_uint32_post(char *name, prs_struct * ps, int depth, uint32 * data32,
+		      uint32 ptr_uint32, uint32 data_size);
+int prs_tdb_delete(TDB_CONTEXT * tdb, prs_struct * pk);
+int prs_tdb_store(TDB_CONTEXT * tdb, int flgs, prs_struct * pk,
+		  prs_struct * pd);
+void prs_tdb_fetch(TDB_CONTEXT * tdb, prs_struct * pk, prs_struct * pd);
 
 /*The following definitions come from  rpc_parse/parse_rpc.c  */
 
-BOOL make_rpc_hdr(RPC_HDR *hdr, enum RPC_PKT_TYPE pkt_type, uint8 flags,
-				uint32 call_id, int data_len, int auth_len);
-BOOL smb_io_rpc_hdr(char *desc,  RPC_HDR *rpc, prs_struct *ps, int depth);
-BOOL is_complete_pdu(prs_struct *ps);
-BOOL smb_io_rpc_hdr_nack(char *desc,  RPC_HDR_NACK *rpc, prs_struct *ps, int depth);
-BOOL smb_io_rpc_hdr_fault(char *desc,  RPC_HDR_FAULT *rpc, prs_struct *ps, int depth);
-BOOL make_rpc_hdr_rb(RPC_HDR_RB *rpc, 
-				uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid,
-				uint32 num_elements, uint16 context_id, uint8 num_syntaxes,
-				RPC_IFACE *abstract, RPC_IFACE *transfer);
-BOOL smb_io_rpc_hdr_rb(char *desc,  RPC_HDR_RB *rpc, prs_struct *ps, int depth);
-BOOL make_rpc_hdr_ba(RPC_HDR_BA *rpc, 
-				uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid,
-				const char *pipe_addr,
-				uint8 num_results, uint16 result, uint16 reason,
-				RPC_IFACE *transfer);
-BOOL smb_io_rpc_hdr_ba(char *desc,  RPC_HDR_BA *rpc, prs_struct *ps, int depth);
-BOOL make_rpc_hdr_req(RPC_HDR_REQ *hdr, uint32 alloc_hint, uint16 vuid,
-				uint16 opnum);
-BOOL smb_io_rpc_hdr_req(char *desc,  RPC_HDR_REQ *rpc, prs_struct *ps, int depth);
-BOOL smb_io_rpc_hdr_resp(char *desc,  RPC_HDR_RESP *rpc, prs_struct *ps, int depth);
-BOOL make_rpc_hdr_autha(RPC_HDR_AUTHA *rai,
-				uint16 max_tsize, uint16 max_rsize,
-				uint8 auth_type, uint8 auth_level,
-				uint8 stub_type_len);
-BOOL smb_io_rpc_hdr_autha(char *desc, RPC_HDR_AUTHA *rai, prs_struct *ps, int depth);
-BOOL make_rpc_hdr_auth(RPC_HDR_AUTH *rai,
-				uint8 auth_type, uint8 auth_level,
-				uint8 stub_type_len,
-				uint32 ptr);
-BOOL smb_io_rpc_hdr_auth(char *desc, RPC_HDR_AUTH *rai, prs_struct *ps, int depth);
-BOOL make_rpc_auth_verifier(RPC_AUTH_VERIFIER *rav,
-				char *signature, uint32 msg_type);
-BOOL smb_io_rpc_auth_verifier(char *desc, RPC_AUTH_VERIFIER *rav, prs_struct *ps, int depth);
-BOOL rpc_auth_verifier_chk(RPC_AUTH_VERIFIER *rav,
-				char *signature, uint32 msg_type);
+BOOL make_rpc_hdr(RPC_HDR * hdr, enum RPC_PKT_TYPE pkt_type, uint8 flags,
+		  uint32 call_id, int frag_len, int auth_len);
+BOOL smb_io_rpc_hdr(char *desc, RPC_HDR * rpc, prs_struct * ps, int depth);
+BOOL is_complete_pdu(prs_struct * ps);
+BOOL smb_io_rpc_hdr_nack(char *desc, RPC_HDR_NACK * rpc, prs_struct * ps,
+			 int depth);
+BOOL smb_io_rpc_hdr_fault(char *desc, RPC_HDR_FAULT * rpc, prs_struct * ps,
+			  int depth);
+BOOL make_rpc_hdr_rb(RPC_HDR_RB * rpc,
+		     uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid,
+		     uint32 num_elements, uint16 context_id,
+		     uint8 num_syntaxes, RPC_IFACE * abstract,
+		     RPC_IFACE * transfer);
+BOOL smb_io_rpc_hdr_rb(char *desc, RPC_HDR_RB * rpc, prs_struct * ps,
+		       int depth);
+BOOL make_rpc_hdr_ba(RPC_HDR_BA * rpc,
+		     uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid,
+		     const char *pipe_addr,
+		     uint8 num_results, uint16 result, uint16 reason,
+		     RPC_IFACE * transfer);
+BOOL smb_io_rpc_hdr_ba(char *desc, RPC_HDR_BA * rpc, prs_struct * ps,
+		       int depth);
+BOOL make_rpc_hdr_req(RPC_HDR_REQ * hdr, uint32 alloc_hint, uint16 vuid,
+		      uint16 opnum);
+BOOL smb_io_rpc_hdr_req(char *desc, RPC_HDR_REQ * rpc, prs_struct * ps,
+			int depth);
+BOOL smb_io_rpc_hdr_resp(char *desc, RPC_HDR_RESP * rpc, prs_struct * ps,
+			 int depth);
+BOOL make_rpc_hdr_autha(RPC_HDR_AUTHA * rai,
+			uint16 max_tsize, uint16 max_rsize,
+			uint8 auth_type, uint8 auth_level,
+			uint8 stub_type_len);
+BOOL smb_io_rpc_hdr_autha(char *desc, RPC_HDR_AUTHA * rai, prs_struct * ps,
+			  int depth);
+BOOL make_rpc_hdr_auth(RPC_HDR_AUTH * rai,
+		       uint8 auth_type, uint8 auth_level,
+		       uint8 stub_type_len, uint32 ptr);
+BOOL smb_io_rpc_hdr_auth(char *desc, RPC_HDR_AUTH * rai, prs_struct * ps,
+			 int depth);
+BOOL make_rpc_auth_verifier(RPC_AUTH_VERIFIER * rav,
+			    char *signature, uint32 msg_type);
+BOOL smb_io_rpc_auth_verifier(char *desc, RPC_AUTH_VERIFIER * rav,
+			      prs_struct * ps, int depth);
+BOOL rpc_auth_verifier_chk(RPC_AUTH_VERIFIER * rav,
+			   char *signature, uint32 msg_type);
 
 /*The following definitions come from  rpc_parse/parse_samr.c  */
 
@@ -2269,14 +2291,16 @@ BOOL make_samr_r_query_usergroups(SAMR_R_QUERY_USERGROUPS *r_u,
 		uint32 num_gids, DOM_GID *gid, uint32 status);
 BOOL samr_io_gids(char *desc, uint32 *num_gids, DOM_GID **gid, prs_struct *ps, int depth);
 BOOL samr_io_r_query_usergroups(char *desc, SAMR_R_QUERY_USERGROUPS *r_u, prs_struct *ps, int depth);
-BOOL make_samr_q_enum_domains(SAMR_Q_ENUM_DOMAINS *q_e, POLICY_HND *pol,
-				uint32 start_idx, uint32 size);
+BOOL make_samr_q_enum_domains(SAMR_Q_ENUM_DOMAINS *q_e,
+			      const POLICY_HND *pol,
+			      uint32 start_idx, uint32 size);
 BOOL samr_io_q_enum_domains(char *desc, SAMR_Q_ENUM_DOMAINS *q_e, prs_struct *ps, int depth);
 BOOL make_samr_r_enum_domains(SAMR_R_ENUM_DOMAINS *r_u,
 		uint32 next_idx, uint32 num_sam_entries);
 BOOL samr_io_r_enum_domains(char *desc, SAMR_R_ENUM_DOMAINS *r_u, prs_struct *ps, int depth);
-BOOL make_samr_q_enum_dom_groups(SAMR_Q_ENUM_DOM_GROUPS *q_e, POLICY_HND *pol,
-				uint32 start_idx, uint32 size);
+BOOL make_samr_q_enum_dom_groups(SAMR_Q_ENUM_DOM_GROUPS *q_e,
+				 const POLICY_HND *pol,
+				 uint32 start_idx, uint32 size);
 BOOL samr_io_q_enum_dom_groups(char *desc, SAMR_Q_ENUM_DOM_GROUPS *q_e, prs_struct *ps, int depth);
 BOOL make_samr_r_enum_dom_groups(SAMR_R_ENUM_DOM_GROUPS *r_u,
 		uint32 next_idx, uint32 num_sam_entries);
@@ -2292,19 +2316,20 @@ BOOL make_samr_alias_info3(ALIAS_INFO3 *al3, const char *acct_desc);
 BOOL samr_io_alias_info3(char *desc,  ALIAS_INFO3 *al3, prs_struct *ps, int depth);
 BOOL samr_alias_info_ctr(char *desc,  ALIAS_INFO_CTR *ctr, prs_struct *ps, int depth);
 BOOL make_samr_q_query_aliasinfo(SAMR_Q_QUERY_ALIASINFO *q_e,
-				POLICY_HND *pol,
-				uint16 switch_level);
+				 const POLICY_HND *pol, uint16 switch_level);
 BOOL samr_io_q_query_aliasinfo(char *desc,  SAMR_Q_QUERY_ALIASINFO *q_e, prs_struct *ps, int depth);
-BOOL make_samr_r_query_aliasinfo(SAMR_R_QUERY_ALIASINFO *r_u, ALIAS_INFO_CTR *ctr,
-		uint32 status);
+BOOL make_samr_r_query_aliasinfo(SAMR_R_QUERY_ALIASINFO *r_u,
+				 ALIAS_INFO_CTR *ctr, uint32 status);
 BOOL samr_io_r_query_aliasinfo(char *desc,  SAMR_R_QUERY_ALIASINFO *r_u, prs_struct *ps, int depth);
-BOOL make_samr_q_set_aliasinfo(SAMR_Q_SET_ALIASINFO *q_u, POLICY_HND *hnd,
-				ALIAS_INFO_CTR *ctr);
+BOOL make_samr_q_set_aliasinfo(SAMR_Q_SET_ALIASINFO *q_u,
+			       const POLICY_HND *hnd,
+			       ALIAS_INFO_CTR *ctr);
 BOOL samr_io_q_set_aliasinfo(char *desc,  SAMR_Q_SET_ALIASINFO *q_u, prs_struct *ps, int depth);
 BOOL samr_io_r_set_aliasinfo(char *desc,  SAMR_R_SET_ALIASINFO *r_u, prs_struct *ps, int depth);
 BOOL make_samr_q_query_useraliases(SAMR_Q_QUERY_USERALIASES *q_u,
-				const POLICY_HND *hnd,
-				uint32 *ptr_sid, DOM_SID2 *sid);
+				   const POLICY_HND *hnd,
+				   uint32  num_sids,
+				   uint32 *ptr_sid, DOM_SID2 *sid);
 BOOL samr_io_q_query_useraliases(char *desc,  SAMR_Q_QUERY_USERALIASES *q_u, prs_struct *ps, int depth);
 void samr_free_q_query_useraliases(SAMR_Q_QUERY_USERALIASES *q_u);
 BOOL make_samr_r_query_useraliases(SAMR_R_QUERY_USERALIASES *r_u,
diff --git a/source/rpc_client/cli_pipe.c b/source/rpc_client/cli_pipe.c
index c1fedbdf149..d621c44ed1f 100644
--- a/source/rpc_client/cli_pipe.c
+++ b/source/rpc_client/cli_pipe.c
@@ -910,8 +910,8 @@ static BOOL check_bind_response(RPC_HDR_BA * hdr_ba, const char *pipe_name,
 
 	/* check the transfer syntax */
 	if (!((hdr_ba->transfer.version == transfer->version) &&
-	      (memcmp(hdr_ba->transfer.data, transfer->data,
-		      sizeof(transfer->version)) == 0)))
+	      (memcmp(&hdr_ba->transfer.uuid, &transfer->uuid,
+		      sizeof(transfer->uuid)) == 0)))
 	{
 		DEBUG(0, ("bind_rpc_pipe: transfer syntax differs\n"));
 		return False;
diff --git a/source/rpc_parse/parse_prs.c b/source/rpc_parse/parse_prs.c
index 49481f7f2e7..3509f996b8b 100644
--- a/source/rpc_parse/parse_prs.c
+++ b/source/rpc_parse/parse_prs.c
@@ -28,21 +28,24 @@ extern int DEBUGLEVEL;
 /*******************************************************************
  debug output for parsing info.
  ********************************************************************/
-void prs_debug(prs_struct *ps, int depth, const char *desc, const char *fn_name)
+void prs_debug(prs_struct * ps, int depth, const char *desc,
+	       const char *fn_name)
 {
 	CHECK_STRUCT(ps);
-	DEBUG(5+depth, ("%s%06x %s %s\n", tab_depth(depth), ps->offset, fn_name, desc));
+	DEBUG(5 + depth,
+	      ("%s%06x %s %s\n", tab_depth(depth), ps->offset, fn_name,
+	       desc));
 }
 
 /*******************************************************************
  debug a parse structure
  ********************************************************************/
-void prs_debug_out(const prs_struct *ps, char *msg, int level)
+void prs_debug_out(const prs_struct * ps, char *msg, int level)
 {
 	CHECK_STRUCT(ps);
-	DEBUG(level,("%s ps: io %s align %d offset %d err %d data %p\n",
-		msg, BOOLSTR(ps->io), ps->align, ps->offset, ps->error,
-		ps->data));
+	DEBUG(level, ("%s ps: io %s align %d offset %d err %d data %p\n",
+		      msg, BOOLSTR(ps->io), ps->align, ps->offset, ps->error,
+		      ps->data));
 
 	if (ps->data != NULL)
 	{
@@ -53,7 +56,7 @@ void prs_debug_out(const prs_struct *ps, char *msg, int level)
 /*******************************************************************
  initialise a parse structure
  ********************************************************************/
-void prs_init(prs_struct *ps, uint32 size, uint8 align,  BOOL io)
+void prs_init(prs_struct * ps, uint32 size, uint8 align, BOOL io)
 {
 	ps->struct_start = 0xfefefefe;
 	ps->io = io;
@@ -66,7 +69,7 @@ void prs_init(prs_struct *ps, uint32 size, uint8 align,  BOOL io)
 	ps->data_size = 0;
 
 	ps->start = 0;
-	ps->end   = 0;
+	ps->end = 0;
 
 	ps->next = NULL;
 
@@ -75,7 +78,7 @@ void prs_init(prs_struct *ps, uint32 size, uint8 align,  BOOL io)
 	if (size != 0)
 	{
 		prs_realloc_data(ps, size);
-		ps->end   = 0xffffffff;
+		ps->end = 0xffffffff;
 	}
 
 	CHECK_STRUCT(ps);
@@ -84,19 +87,22 @@ void prs_init(prs_struct *ps, uint32 size, uint8 align,  BOOL io)
 /*******************************************************************
  set the packed data representation type in a parse structure
  ********************************************************************/
-void prs_set_packtype(prs_struct *ps, const uint8 *pack_type)
+void prs_set_packtype(prs_struct * ps, const uint8 * pack_type)
 {
 	CHECK_STRUCT(ps);
 	ps->bigendian = pack_type[0] == 0x0;
+	DEBUG(10,
+	      ("prs_set_packtype: bigendian: %s\n", BOOLSTR(ps->bigendian)));
 }
 
 /*******************************************************************
  create a parse structure
  ********************************************************************/
-void prs_create(prs_struct *ps, char *data, uint32 size, uint8 align, BOOL io)
+void prs_create(prs_struct * ps, char *data, uint32 size, uint8 align,
+		BOOL io)
 {
-	DEBUG(200,("prs_create: data:%p size:%d align:%d io:%s\n",
-	            data, size, align, BOOLSTR(io)));
+	DEBUG(200, ("prs_create: data:%p size:%d align:%d io:%s\n",
+		    data, size, align, BOOLSTR(io)));
 
 	prs_init(ps, 0, align, io);
 	ps->data = data;
@@ -109,7 +115,7 @@ void prs_create(prs_struct *ps, char *data, uint32 size, uint8 align, BOOL io)
 /*******************************************************************
  copy a parse structure
  ********************************************************************/
-BOOL prs_copy(prs_struct *ps, const prs_struct *from)
+BOOL prs_copy(prs_struct * ps, const prs_struct * from)
 {
 	int len = prs_buf_len(from);
 	CHECK_STRUCT(ps);
@@ -135,24 +141,24 @@ BOOL prs_copy(prs_struct *ps, const prs_struct *from)
 /*******************************************************************
  allocate a memory buffer.  assume it's empty
  ********************************************************************/
-BOOL prs_alloc_data(prs_struct *buf, int size)
+BOOL prs_alloc_data(prs_struct * buf, int size)
 {
 	CHECK_STRUCT(buf);
 
 	buf->data_size = size;
-	buf->data = (char*)malloc(buf->data_size);
+	buf->data = (char *)malloc(buf->data_size);
 
 	if (buf->data == NULL && size != 0)
 	{
-		DEBUG(3,("prs_alloc: could not malloc size %d\n",
-					  buf->data_size));
+		DEBUG(3, ("prs_alloc: could not malloc size %d\n",
+			  buf->data_size));
 		buf->data_size = 0;
 
 		return False;
 	}
 
 	bzero(buf->data, buf->data_size);
-	buf->end   = buf->start + size;
+	buf->end = buf->start + size;
 
 	CHECK_STRUCT(buf);
 	return True;
@@ -161,27 +167,29 @@ BOOL prs_alloc_data(prs_struct *buf, int size)
 /*******************************************************************
  search for a memory buffer that falls within the specified offset
  ********************************************************************/
-static const prs_struct *prs_find(const prs_struct *buf, uint32 offset)
+static const prs_struct *prs_find(const prs_struct * buf, uint32 offset)
 {
 	const prs_struct *f;
-	if (buf == NULL) return False;
+	if (buf == NULL)
+		return False;
 
 	f = buf;
 
 	CHECK_STRUCT(f);
-	DEBUG(200,("prs_find: data[%d..%d] offset: %d\n",
-	      f->start, f->end, offset));
+	DEBUG(200, ("prs_find: data[%d..%d] offset: %d\n",
+		    f->start, f->end, offset));
 
 	while (f != NULL && offset >= f->end)
 	{
-		DEBUG(200,("prs_find: next[%d..%d]\n", f->start, f->end));
+		DEBUG(200, ("prs_find: next[%d..%d]\n", f->start, f->end));
 
 		f = f->next;
 	}
 
 	if (f != NULL)
 	{
-		DEBUG(200,("prs_find: found data[%d..%d]\n", f->start, f->end));
+		DEBUG(200,
+		      ("prs_find: found data[%d..%d]\n", f->start, f->end));
 	}
 
 	return f;
@@ -190,20 +198,21 @@ static const prs_struct *prs_find(const prs_struct *buf, uint32 offset)
 /*******************************************************************
  allocates a memory buffer structure
  ********************************************************************/
-BOOL prs_buf_copy(char *copy_into, const prs_struct *buf,
-				uint32 offset, uint32 len)
+BOOL prs_buf_copy(char *copy_into, const prs_struct * buf,
+		  uint32 offset, uint32 len)
 {
 	uint32 end = offset + len;
 	char *q = NULL;
 	uint32 data_len = prs_buf_len(buf);
 	uint32 start_offset = offset;
 	const prs_struct *bcp = buf;
-	
-	if (buf == NULL || copy_into == NULL) return False;
+
+	if (buf == NULL || copy_into == NULL)
+		return False;
 
 	CHECK_STRUCT(buf);
-	DEBUG(200,("prs_struct_copy: data[%d..%d] offset %d len %d\n",
-	            buf->start, data_len, offset, len));
+	DEBUG(200, ("prs_struct_copy: data[%d..%d] offset %d len %d\n",
+		    buf->start, data_len, offset, len));
 
 	prs_debug_out(bcp, "prs_struct_copy", 200);
 
@@ -214,23 +223,24 @@ BOOL prs_buf_copy(char *copy_into, const prs_struct *buf,
 		bcp = prs_find(bcp, offset);
 		copy_len = bcp->end - offset;
 
-		DEBUG(200,("\tdata[%d..%d] - offset %d len %d\n",
-		        bcp->start, bcp->end,
-		        offset, copy_len));
+		DEBUG(200, ("\tdata[%d..%d] - offset %d len %d\n",
+			    bcp->start, bcp->end, offset, copy_len));
 
 		memcpy(copy_into, q, copy_len);
-	
-		offset    += copy_len;
+
+		offset += copy_len;
 		copy_into += copy_len;
 	}
 
 	if (bcp != NULL)
 	{
-		DEBUG(200,("prs_struct_copy: copied %d bytes\n", offset - start_offset));
+		DEBUG(200,
+		      ("prs_struct_copy: copied %d bytes\n",
+		       offset - start_offset));
 	}
 	else
 	{
-		DEBUG(200,("prs_struct_copy: failed\n"));
+		DEBUG(200, ("prs_struct_copy: failed\n"));
 	}
 
 	return buf != NULL;
@@ -239,29 +249,33 @@ BOOL prs_buf_copy(char *copy_into, const prs_struct *buf,
 /*******************************************************************
  frees up a memory buffer.
  ********************************************************************/
-void prs_struct_free(prs_struct **buf)
+void prs_struct_free(prs_struct ** buf)
 {
-	if (buf == NULL) return;
-	if ((*buf) == NULL) return;
+	if (buf == NULL)
+		return;
+	if ((*buf) == NULL)
+		return;
 
 	CHECK_STRUCT(*buf);
-	prs_free_data(*buf);            /* delete memory data */
-	free(*buf);                     /* delete item */
+	prs_free_data(*buf);	/* delete memory data */
+	free(*buf);		/* delete item */
 	(*buf) = NULL;
 }
 
 /*******************************************************************
  frees a memory buffer chain.  assumes that all items are malloced.
  ********************************************************************/
-static void prs_free_chain(prs_struct **buf)
+static void prs_free_chain(prs_struct ** buf)
 {
-	if (buf == NULL) return;
-	if ((*buf) == NULL) return;
+	if (buf == NULL)
+		return;
+	if ((*buf) == NULL)
+		return;
 
 	CHECK_STRUCT(*buf);
 	if ((*buf)->next != NULL)
 	{
-		prs_free_chain(&((*buf)->next)); /* delete all other items in chain */
+		prs_free_chain(&((*buf)->next));	/* delete all other items in chain */
 	}
 	prs_struct_free(buf);
 }
@@ -269,14 +283,15 @@ static void prs_free_chain(prs_struct **buf)
 /*******************************************************************
  frees a memory buffer.
  ********************************************************************/
-void prs_free_data(prs_struct *buf)
+void prs_free_data(prs_struct * buf)
 {
-	if (buf == NULL) return;
+	if (buf == NULL)
+		return;
 
 	if (buf->data != NULL)
 	{
 		CHECK_STRUCT(buf);
-		free(buf->data);     /* delete data in this structure */
+		free(buf->data);	/* delete data in this structure */
 		buf->data = NULL;
 	}
 	buf->data_size = 0;
@@ -291,8 +306,10 @@ static void *prs_realloc(void *p, size_t size)
 		return NULL;
 	}
 	ret = (void *)malloc(size);
-	if (!ret) return NULL;
-	if (p) {
+	if (!ret)
+		return NULL;
+	if (p)
+	{
 		memcpy(ret, p, size);
 		memset(p, 0, 1);
 	}
@@ -303,7 +320,7 @@ static void *prs_realloc(void *p, size_t size)
 /*******************************************************************
  reallocate a memory buffer
 ********************************************************************/
-BOOL prs_realloc_data(prs_struct *buf, size_t new_size)
+BOOL prs_realloc_data(prs_struct * buf, size_t new_size)
 {
 	char *new_data;
 
@@ -317,32 +334,35 @@ BOOL prs_realloc_data(prs_struct *buf, size_t new_size)
 		return True;
 	}
 
-	new_data = (char*)Realloc(buf->data, new_size);
+	new_data = (char *)Realloc(buf->data, new_size);
 
 	if (new_data != NULL)
 	{
 		if (new_size > buf->data_size)
 		{
-			memset(&new_data[buf->data_size], 0, new_size - buf->data_size);
+			memset(&new_data[buf->data_size], 0,
+			       new_size - buf->data_size);
 		}
 		buf->data = new_data;
 		buf->data_size = new_size;
 	}
 	else if (buf->data_size >= new_size)
 	{
-		DEBUG(3,("prs_realloc_data: warning - could not realloc to %d\n",
-				  new_size));
+		DEBUG(3,
+		      ("prs_realloc_data: warning - could not realloc to %d\n",
+		       new_size));
 	}
-	else 
+	else
 	{
-		DEBUG(3,("prs_realloc_data: error - could not realloc to %d\n",
-				  new_size));
+		DEBUG(3,
+		      ("prs_realloc_data: error - could not realloc to %d\n",
+		       new_size));
 
 		prs_free_data(buf);
 		return False;
 	}
 
-	buf->end   = buf->start + new_size;
+	buf->end = buf->start + new_size;
 
 	prs_debug_out(buf, "prs_realloc_data - after", 200);
 	return True;
@@ -351,7 +371,7 @@ BOOL prs_realloc_data(prs_struct *buf, size_t new_size)
 /*******************************************************************
  reallocate a memory buffer, retrospectively :-)
  ********************************************************************/
-BOOL prs_grow_data(prs_struct *buf, BOOL io, int new_size, BOOL force_grow)
+BOOL prs_grow_data(prs_struct * buf, BOOL io, int new_size, BOOL force_grow)
 {
 	if (buf == NULL)
 	{
@@ -378,7 +398,7 @@ BOOL prs_grow_data(prs_struct *buf, BOOL io, int new_size, BOOL force_grow)
 /*******************************************************************
  add up the lengths of all sections.
  ********************************************************************/
-uint32 prs_buf_len(const prs_struct *buf)
+uint32 prs_buf_len(const prs_struct * buf)
 {
 	int len = 0;
 	CHECK_STRUCT(buf);
@@ -393,7 +413,7 @@ uint32 prs_buf_len(const prs_struct *buf)
 /*******************************************************************
  return the memory location specified by   may return NULL.
  ********************************************************************/
-char *prs_data(const prs_struct *buf, uint32 offset)
+char *prs_data(const prs_struct * buf, uint32 offset)
 {
 	CHECK_STRUCT(buf);
 	buf = prs_find(buf, offset);
@@ -408,7 +428,7 @@ char *prs_data(const prs_struct *buf, uint32 offset)
 /*******************************************************************
  link one parsing structure to another
  ********************************************************************/
-void prs_link(prs_struct *prev, prs_struct *ps, prs_struct *next)
+void prs_link(prs_struct * prev, prs_struct * ps, prs_struct * next)
 {
 	CHECK_STRUCT(ps);
 	if (next != NULL)
@@ -420,23 +440,24 @@ void prs_link(prs_struct *prev, prs_struct *ps, prs_struct *next)
 		CHECK_STRUCT(prev);
 	}
 	ps->start = prev != NULL ? prev->end : 0;
-	ps->end   = ps->start + ps->offset;
+	ps->end = ps->start + ps->offset;
 
 	ps->next = next;
 
-	DEBUG(150,("prs_link: start %d end %d\n", ps->start, ps->end));
+	DEBUG(150, ("prs_link: start %d end %d\n", ps->start, ps->end));
 }
 
 /*******************************************************************
  align a pointer to a multiple of align_offset bytes.  looks like it
  will work for offsets of 0, 2 and 4...
  ********************************************************************/
-void prs_align(prs_struct *ps)
+void prs_align(prs_struct * ps)
 {
 	int mod;
 	CHECK_STRUCT(ps);
-	if (ps->error) return;
-	mod = ps->offset & (ps->align-1);
+	if (ps->error)
+		return;
+	mod = ps->offset & (ps->align - 1);
 	if (ps->align != 0 && mod != 0)
 	{
 		ps->offset += ps->align - mod;
@@ -449,24 +470,25 @@ void prs_align(prs_struct *ps)
 
  depends on the data stream mode (io)
  ********************************************************************/
-BOOL prs_grow(prs_struct *ps, uint32 new_size)
+BOOL prs_grow(prs_struct * ps, uint32 new_size)
 {
 	CHECK_STRUCT(ps);
-	if (ps->error) return False;
+	if (ps->error)
+		return False;
 	return prs_grow_data(ps, ps->io, new_size, False);
 }
 
 /*******************************************************************
  lengthens a buffer by len bytes and copies data into it.
  ********************************************************************/
-BOOL prs_append_data(prs_struct *ps, const char *data, int len)
+BOOL prs_append_data(prs_struct * ps, const char *data, int len)
 {
 	int prev_size = ps->data_size;
-	int new_size  = prev_size + len;
+	int new_size = prev_size + len;
 	char *to;
 
-	DEBUG(200,("prs_append_data: prev_size: %d new_size: %d\n",
-	            prev_size, new_size));
+	DEBUG(200, ("prs_append_data: prev_size: %d new_size: %d\n",
+		    prev_size, new_size));
 
 	CHECK_STRUCT(ps);
 	prs_realloc_data(ps, new_size);
@@ -481,7 +503,7 @@ BOOL prs_append_data(prs_struct *ps, const char *data, int len)
 	return True;
 }
 
-BOOL prs_add_data(prs_struct *ps, const char *data, int len)
+BOOL prs_add_data(prs_struct * ps, const char *data, int len)
 {
 	int prev_size;
 	int new_size;
@@ -491,10 +513,10 @@ BOOL prs_add_data(prs_struct *ps, const char *data, int len)
 
 	if (ps->data == NULL)
 	{
-		DEBUG(10,("prs_add_data: new_size: %d\n", len));
+		DEBUG(10, ("prs_add_data: new_size: %d\n", len));
 		prs_init(ps, len, 4, True);
 		prev_size = 0;
-		new_size  = len;
+		new_size = len;
 		if (ps->data == NULL)
 		{
 			return False;
@@ -503,28 +525,28 @@ BOOL prs_add_data(prs_struct *ps, const char *data, int len)
 	else
 	{
 		prev_size = ps->data_size;
-		new_size  = prev_size + len;
-		DEBUG(10,("prs_add_data: prev_size: %d new_size: %d\n",
-				prev_size, new_size));
+		new_size = prev_size + len;
+		DEBUG(10, ("prs_add_data: prev_size: %d new_size: %d\n",
+			   prev_size, new_size));
 		if (!prs_realloc_data(ps, new_size))
 		{
 			return False;
 		}
 	}
 
-	DEBUG(10,("ps->start: %d\n", ps->start));
+	DEBUG(10, ("ps->start: %d\n", ps->start));
 	ps->start = 0x0;
 
 	to = prs_data(ps, prev_size);
 	if (to == NULL)
 	{
-		DEBUG(10,("prs_add_data: data could not be found\n"));
+		DEBUG(10, ("prs_add_data: data could not be found\n"));
 		return False;
 	}
 	if (ps->data_size != new_size)
 	{
-		DEBUG(10,("prs_add_data: ERROR: data used %d new_size %d\n",
-				ps->data_size, new_size));
+		DEBUG(10, ("prs_add_data: ERROR: data used %d new_size %d\n",
+			   ps->data_size, new_size));
 		return False;
 	}
 	memcpy(to, data, len);
@@ -534,11 +556,12 @@ BOOL prs_add_data(prs_struct *ps, const char *data, int len)
 /*******************************************************************
  stream a uint8
  ********************************************************************/
-BOOL _prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8)
+BOOL _prs_uint8(char *name, prs_struct * ps, int depth, uint8 * data8)
 {
 	char *q;
 	CHECK_STRUCT(ps);
-	if (ps->error) return False;
+	if (ps->error)
+		return False;
 	prs_grow(ps, ps->offset + 1);
 	q = prs_data(ps, ps->offset);
 	if (q == NULL)
@@ -549,7 +572,7 @@ BOOL _prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8)
 	}
 
 	DBG_RW_CVAL(name, depth, ps->offset, ps->io, q, *data8)
-	ps->offset += 1;
+		ps->offset += 1;
 
 
 	return True;
@@ -558,11 +581,12 @@ BOOL _prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8)
 /*******************************************************************
  stream a uint16
  ********************************************************************/
-BOOL _prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
+BOOL _prs_uint16(char *name, prs_struct * ps, int depth, uint16 * data16)
 {
 	char *q;
 	CHECK_STRUCT(ps);
-	if (ps->error) return False;
+	if (ps->error)
+		return False;
 	prs_grow(ps, ps->offset + 2);
 	q = prs_data(ps, ps->offset);
 	if (q == NULL)
@@ -572,7 +596,7 @@ BOOL _prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
 		return False;
 	}
 
-	DBG_RW_SVAL(name, depth, ps->offset, ps->io, ps->bigendian, q, *data16)
+	DBG_RW_SVAL(name, depth, ps->offset, ps->io, ps->bigendian, q, *data16);
 	ps->offset += 2;
 
 	return True;
@@ -581,11 +605,12 @@ BOOL _prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
 /*******************************************************************
  hash a stream.
  ********************************************************************/
-BOOL _prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
+BOOL _prs_hash1(prs_struct * ps, uint32 offset, uint8 sess_key[16])
 {
 	char *q;
 	CHECK_STRUCT(ps);
-	if (ps->error) return False;
+	if (ps->error)
+		return False;
 	q = prs_data(ps, ps->offset);
 	if (q == NULL)
 	{
@@ -595,11 +620,11 @@ BOOL _prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
 	}
 
 #ifdef DEBUG_PASSWORD
-	DEBUG(100,("prs_hash1\n"));
+	DEBUG(100, ("prs_hash1\n"));
 	dump_data(100, sess_key, 16);
 	dump_data(100, q, 68);
 #endif
-	SamOEMhash((uchar*)q, sess_key, 2);
+	SamOEMhash((uchar *) q, sess_key, 2);
 #ifdef DEBUG_PASSWORD
 	dump_data(100, q, 68);
 #endif
@@ -610,23 +635,25 @@ BOOL _prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
 /*******************************************************************
  stream a uint32
  ********************************************************************/
-BOOL _prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
+BOOL _prs_uint32(char *name, prs_struct * ps, int depth, uint32 * data32)
 {
 	char *q;
 	CHECK_STRUCT(ps);
-	if (ps->error) return False;
+	if (ps->error)
+		return False;
 	prs_grow(ps, ps->offset + 4);
 	q = prs_data(ps, ps->offset);
 	if (q == NULL)
 	{
 		fstring str;
-		slprintf(str, sizeof(str)-1, "_prs_uint32 error (%s)", name);
+		slprintf(str, sizeof(str) - 1, "_prs_uint32 error (%s)",
+			 name);
 		ps->error = True;
 		prs_debug_out(ps, str, 5);
 		return False;
 	}
 
-	DBG_RW_IVAL(name, depth, ps->offset, ps->io, ps->bigendian, q, *data32)
+	DBG_RW_IVAL(name, depth, ps->offset, ps->io, ps->bigendian, q, *data32);
 	ps->offset += 4;
 
 	return True;
@@ -636,7 +663,8 @@ BOOL _prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
 /******************************************************************
  stream an array of uint8s.  length is number of uint8s
  ********************************************************************/
-BOOL _prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
+BOOL _prs_uint8s(BOOL charmode, char *name, prs_struct * ps, int depth,
+		 uint8 * data8s, int len)
 {
 	char *q;
 	int end_offset;
@@ -648,21 +676,22 @@ BOOL _prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *da
 		return True;
 	}
 
-	if (ps->error) return False;
+	if (ps->error)
+		return False;
 	end_offset = ps->offset + len * sizeof(uint8);
 	prs_grow(ps, end_offset);
 	q = prs_data(ps, ps->offset);
-	e = prs_data(ps, end_offset-1);
+	e = prs_data(ps, end_offset - 1);
 
-	if (q == NULL || e == NULL) 
+	if (q == NULL || e == NULL)
 	{
 		ps->error = True;
 		prs_debug_out(ps, "_prs_uint8s error", 5);
 		return False;
 	}
 
-	DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q, data8s, len)
-	ps->offset = end_offset;
+	DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q, data8s,
+		     len) ps->offset = end_offset;
 
 	return True;
 }
@@ -670,13 +699,15 @@ BOOL _prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *da
 /******************************************************************
  stream an array of uint16s.  length is number of uint16s
  ********************************************************************/
-BOOL _prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
+BOOL _prs_uint16s(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  uint16 * data16s, int len)
 {
 	char *q;
 	int end_offset;
 	char *e;
 	CHECK_STRUCT(ps);
-	if (ps->error) return False;
+	if (ps->error)
+		return False;
 
 	if (len == 0)
 	{
@@ -686,7 +717,7 @@ BOOL _prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *
 	end_offset = ps->offset + len * sizeof(uint16);
 	prs_grow(ps, end_offset);
 	q = prs_data(ps, ps->offset);
-	e = prs_data(ps, end_offset-1);
+	e = prs_data(ps, end_offset - 1);
 
 	if (q == NULL || e == NULL)
 	{
@@ -695,7 +726,7 @@ BOOL _prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *
 		return False;
 	}
 
-	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, ps->bigendian, q, data16s, len)
+	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, ps->bigendian, q, data16s, len);
 	ps->offset = end_offset;
 
 	return True;
@@ -704,13 +735,15 @@ BOOL _prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *
 /******************************************************************
  stream an array of uint32s.  length is number of uint32s
  ********************************************************************/
-BOOL _prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *data32s, int len)
+BOOL _prs_uint32s(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  uint32 * data32s, int len)
 {
 	char *q;
 	int end_offset;
 	char *e;
 	CHECK_STRUCT(ps);
-	if (ps->error) return False;
+	if (ps->error)
+		return False;
 
 	if (len == 0)
 	{
@@ -720,7 +753,7 @@ BOOL _prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *
 	end_offset = ps->offset + len * sizeof(uint32);
 	prs_grow(ps, end_offset);
 	q = prs_data(ps, ps->offset);
-	e = prs_data(ps, end_offset-1);
+	e = prs_data(ps, end_offset - 1);
 
 	if (q == NULL || e == NULL)
 	{
@@ -729,7 +762,7 @@ BOOL _prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *
 		return False;
 	}
 
-	DBG_RW_PIVAL(charmode, name, depth, ps->offset, ps->io, ps->bigendian, q, data32s, len)
+	DBG_RW_PIVAL(charmode, name, depth, ps->offset, ps->io, ps->bigendian, q, data32s, len);
 	ps->offset = end_offset;
 
 	return True;
@@ -739,13 +772,15 @@ BOOL _prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *
  stream a "not" unicode string, length/buffer specified separately,
  in byte chars
  ********************************************************************/
-BOOL _prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *str)
+BOOL _prs_buffer2(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  BUFFER2 * str)
 {
 	char *q;
 	int end_offset;
 	char *e;
 	CHECK_STRUCT(ps);
-	if (ps->error) return False;
+	if (ps->error)
+		return False;
 
 	if (str->buf_len == 0)
 	{
@@ -755,7 +790,7 @@ BOOL _prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2
 	end_offset = ps->offset + str->buf_len * sizeof(uint8);
 	prs_grow(ps, end_offset);
 	q = prs_data(ps, ps->offset);
-	e = prs_data(ps, end_offset-1);
+	e = prs_data(ps, end_offset - 1);
 
 	if (q == NULL || e == NULL)
 	{
@@ -764,8 +799,8 @@ BOOL _prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2
 		return False;
 	}
 
-	DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->buf_len)
-	ps->offset = end_offset;
+	DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q,
+		     str->buffer, str->buf_len) ps->offset = end_offset;
 
 	return True;
 }
@@ -774,13 +809,15 @@ BOOL _prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2
  stream a string, length/buffer specified separately,
  in uint8 chars.
  ********************************************************************/
-BOOL _prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *str)
+BOOL _prs_string2(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  STRING2 * str)
 {
 	char *q;
 	int end_offset;
 	char *e;
 	CHECK_STRUCT(ps);
-	if (ps->error) return False;
+	if (ps->error)
+		return False;
 
 	if (str->str_str_len == 0)
 	{
@@ -790,7 +827,7 @@ BOOL _prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2
 	end_offset = ps->offset + str->str_str_len * sizeof(uint8);
 	prs_grow(ps, end_offset);
 	q = prs_data(ps, ps->offset);
-	e = prs_data(ps, end_offset-1);
+	e = prs_data(ps, end_offset - 1);
 
 	if (q == NULL || e == NULL)
 	{
@@ -799,8 +836,8 @@ BOOL _prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2
 		return False;
 	}
 
-	DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->str_str_len)
-	ps->offset = end_offset;
+	DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q,
+		     str->buffer, str->str_str_len) ps->offset = end_offset;
 
 	return True;
 }
@@ -809,13 +846,15 @@ BOOL _prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2
  stream a unicode string, length/buffer specified separately,
  in uint16 chars.
  ********************************************************************/
-BOOL _prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *str)
+BOOL _prs_unistr2(BOOL charmode, char *name, prs_struct * ps, int depth,
+		  UNISTR2 * str)
 {
 	char *q;
 	int end_offset;
 	char *e;
 	CHECK_STRUCT(ps);
-	if (ps->error) return False;
+	if (ps->error)
+		return False;
 
 	if (str->uni_str_len == 0)
 	{
@@ -825,7 +864,7 @@ BOOL _prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2
 	end_offset = ps->offset + str->uni_str_len * sizeof(uint16);
 	prs_grow(ps, end_offset);
 	q = prs_data(ps, ps->offset);
-	e = prs_data(ps, end_offset-1);
+	e = prs_data(ps, end_offset - 1);
 
 	if (q == NULL || e == NULL)
 	{
@@ -834,7 +873,7 @@ BOOL _prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2
 		return False;
 	}
 
-	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, ps->bigendian, q, str->buffer, str->uni_str_len)
+	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, ps->bigendian, q, str->buffer, str->uni_str_len);
 	ps->offset = end_offset;
 
 	return True;
@@ -844,13 +883,15 @@ BOOL _prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2
  stream a unicode string, length/buffer specified separately,
  in uint16 chars.
  ********************************************************************/
-BOOL _prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int depth)
+BOOL _prs_unistr3(BOOL charmode, char *name, UNISTR3 * str, prs_struct * ps,
+		  int depth)
 {
 	char *q;
 	int end_offset;
 	char *e;
 	CHECK_STRUCT(ps);
-	if (ps->error) return False;
+	if (ps->error)
+		return False;
 
 	if (str->uni_str_len == 0)
 	{
@@ -860,7 +901,7 @@ BOOL _prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int d
 	end_offset = ps->offset + str->uni_str_len * sizeof(uint16);
 	prs_grow(ps, end_offset);
 	q = prs_data(ps, ps->offset);
-	e = prs_data(ps, end_offset-1);
+	e = prs_data(ps, end_offset - 1);
 
 	if (q == NULL || e == NULL)
 	{
@@ -869,7 +910,7 @@ BOOL _prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int d
 		return False;
 	}
 
-	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, ps->bigendian, q, str->str.buffer, str->uni_str_len)
+	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, ps->bigendian, q, str->str.buffer, str->uni_str_len);
 	ps->offset = end_offset;
 
 	return True;
@@ -878,35 +919,36 @@ BOOL _prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int d
 /*******************************************************************
  stream a unicode  null-terminated string
  ********************************************************************/
-BOOL _prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
+BOOL _prs_unistr(char *name, prs_struct * ps, int depth, UNISTR * str)
 {
 	int i = -1;
 	uint8 *start;
 	CHECK_STRUCT(ps);
-	if (ps->error) return False;
-	start = (uint8*)prs_data(ps, ps->offset);
+	if (ps->error)
+		return False;
+	start = (uint8 *) prs_data(ps, ps->offset);
 
 	do
 	{
 		char *q;
 		i++;
-		prs_grow(ps, ps->offset + (i+1)*2);
-		q = prs_data(ps, ps->offset + i*2);
-		if (q == NULL) 
+		prs_grow(ps, ps->offset + (i + 1) * 2);
+		q = prs_data(ps, ps->offset + i * 2);
+		if (q == NULL)
 		{
 			ps->error = True;
 			prs_debug_out(ps, "_prs_unistr error", 5);
 			return False;
 		}
-		RW_SVAL(ps->io, ps->bigendian, q, str->buffer[i],0);
+		RW_SVAL(ps->io, ps->bigendian, q, str->buffer[i], 0);
 	}
-	while ((((size_t)i) < sizeof(str->buffer) / sizeof(str->buffer[0])) &&
-		     (str->buffer[i] != 0));
+	while ((((size_t) i) < sizeof(str->buffer) / sizeof(str->buffer[0]))
+	       && (str->buffer[i] != 0));
 
 
-	ps->offset += (i+1)*2;
+	ps->offset += (i + 1) * 2;
 
-	dump_data(5+depth, (char *)start, i * 2);
+	dump_data(5 + depth, (char *)start, i * 2);
 
 	return True;
 }
@@ -919,31 +961,35 @@ BOOL _prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
  (up to max size of pstring - 1024 chars).
 
  ********************************************************************/
-BOOL _prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, uint16 max_buf_size)
+BOOL _prs_string(char *name, prs_struct * ps, int depth, char *str,
+		 uint16 len, uint16 max_buf_size)
 {
-	int i = -1; /* start off at zero after 1st i++ */
+	int i = -1;		/* start off at zero after 1st i++ */
 	BOOL len_limited;
 
 	CHECK_STRUCT(ps);
-	if (ps->error) return False;
+	if (ps->error)
+		return False;
 
 	len_limited = len == 0 || !ps->io;
 
-	DEBUG(200,("_prs_string: string %s len %d max %d\n",
-			str, len, max_buf_size));
+	DEBUG(200, ("_prs_string: string %s len %d max %d\n",
+		    str, len, max_buf_size));
 
-	DEBUG(10,("%s%04x %s: ", tab_depth(depth), ps->offset, name != NULL ? name : ""));
+	DEBUG(10,
+	      ("%s%04x %s: ", tab_depth(depth), ps->offset,
+	       name != NULL ? name : ""));
 	do
 	{
 		char *q;
 		i++;
 
-		prs_grow(ps, ps->offset + i+1);
+		prs_grow(ps, ps->offset + i + 1);
 		q = prs_data(ps, ps->offset + i);
 		if (q == NULL)
 		{
 			ps->error = True;
-			DEBUG(10,("%s\n", str));
+			DEBUG(10, ("%s\n", str));
 			prs_debug_out(ps, "_prs_string error", 5);
 			return False;
 		}
@@ -955,14 +1001,15 @@ BOOL _prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, u
 		else
 		{
 			uint8 dummy = 0;
-			RW_CVAL(ps->io, q, dummy,0);
+			RW_CVAL(ps->io, q, dummy, 0);
 		}
 
-	} while (i < max_buf_size && (len_limited ? str[i] != 0 : i < len) );
+	}
+	while (i < max_buf_size && (len_limited ? str[i] != 0 : i < len));
 
-	ps->offset += i+1;
+	ps->offset += i + 1;
 
-	DEBUG(10,("%s\n", str));
+	DEBUG(10, ("%s\n", str));
 
 	return True;
 }
@@ -971,10 +1018,12 @@ BOOL _prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, u
  prs_uint16 wrapper.  call this and it sets up a pointer to where the
  uint16 should be stored, or gets the size if reading
  ********************************************************************/
-BOOL _prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
+BOOL _prs_uint16_pre(char *name, prs_struct * ps, int depth, uint16 * data16,
+		     uint32 * offset)
 {
 	CHECK_STRUCT(ps);
-	if (ps->error) return False;
+	if (ps->error)
+		return False;
 	(*offset) = ps->offset;
 	if (ps->io)
 	{
@@ -992,11 +1041,12 @@ BOOL _prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint
  prs_uint16 wrapper.  call this and it retrospectively stores the size.
  does nothing on reading, as that is already handled by ...._pre()
  ********************************************************************/
-BOOL _prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
-				uint32 ptr_uint16, uint32 start_offset)
+BOOL _prs_uint16_post(char *name, prs_struct * ps, int depth, uint16 * data16,
+		      uint32 ptr_uint16, uint32 start_offset)
 {
 	CHECK_STRUCT(ps);
-	if (ps->error) return False;
+	if (ps->error)
+		return False;
 	if (!ps->io)
 	{
 		/* storing: go back and do a retrospective job.  i hate this */
@@ -1018,10 +1068,12 @@ BOOL _prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
  prs_uint32 wrapper.  call this and it sets up a pointer to where the
  uint32 should be stored, or gets the size if reading
  ********************************************************************/
-BOOL _prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
+BOOL _prs_uint32_pre(char *name, prs_struct * ps, int depth, uint32 * data32,
+		     uint32 * offset)
 {
 	CHECK_STRUCT(ps);
-	if (ps->error) return False;
+	if (ps->error)
+		return False;
 	(*offset) = ps->offset;
 	if (ps->io)
 	{
@@ -1039,11 +1091,12 @@ BOOL _prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint
  prs_uint32 wrapper.  call this and it retrospectively stores the size.
  does nothing on reading, as that is already handled by ...._pre()
  ********************************************************************/
-BOOL _prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
-				uint32 ptr_uint32, uint32 data_size)
+BOOL _prs_uint32_post(char *name, prs_struct * ps, int depth, uint32 * data32,
+		      uint32 ptr_uint32, uint32 data_size)
 {
 	CHECK_STRUCT(ps);
-	if (ps->error) return False;
+	if (ps->error)
+		return False;
 	if (!ps->io)
 	{
 		/* storing: go back and do a retrospective job.  i hate this */
@@ -1062,11 +1115,11 @@ BOOL _prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
 /*******************************************************************
  prs_tdb_store.  stores prs_struct data by prs_struct key 
  ********************************************************************/
-int prs_tdb_delete(TDB_CONTEXT *tdb, prs_struct *pk)
+int prs_tdb_delete(TDB_CONTEXT * tdb, prs_struct * pk)
 {
 	TDB_DATA key;
 
-	key.dptr = (char*)prs_data(pk, 0);
+	key.dptr = (char *)prs_data(pk, 0);
 	key.dsize = prs_buf_len(pk);
 
 	return tdb_delete(tdb, key);
@@ -1075,12 +1128,13 @@ int prs_tdb_delete(TDB_CONTEXT *tdb, prs_struct *pk)
 /*******************************************************************
  prs_tdb_store.  stores prs_struct data by prs_struct key 
  ********************************************************************/
-int prs_tdb_store(TDB_CONTEXT *tdb, int flgs, prs_struct *pk, prs_struct *pd)
+int prs_tdb_store(TDB_CONTEXT * tdb, int flgs, prs_struct * pk,
+		  prs_struct * pd)
 {
 	TDB_DATA key;
 	TDB_DATA data;
 
-	key.dptr = (char*)prs_data(pk, 0);
+	key.dptr = (char *)prs_data(pk, 0);
 	key.dsize = prs_buf_len(pk);
 
 	data.dptr = prs_data(pd, 0);
@@ -1092,12 +1146,12 @@ int prs_tdb_store(TDB_CONTEXT *tdb, int flgs, prs_struct *pk, prs_struct *pd)
 /*******************************************************************
  prs_tdb_fetch.  fetches prs_struct data by prs_struct key 
  ********************************************************************/
-void prs_tdb_fetch(TDB_CONTEXT *tdb, prs_struct *pk, prs_struct *pd)
+void prs_tdb_fetch(TDB_CONTEXT * tdb, prs_struct * pk, prs_struct * pd)
 {
 	TDB_DATA key;
 	TDB_DATA data;
 
-	key.dptr = (char*)prs_data(pk, 0);
+	key.dptr = (char *)prs_data(pk, 0);
 	key.dsize = prs_buf_len(pk);
 
 	data = tdb_fetch(tdb, key);
diff --git a/source/rpc_parse/parse_rpc.c b/source/rpc_parse/parse_rpc.c
index 18ba14a0630..c4f8fd06235 100644
--- a/source/rpc_parse/parse_rpc.c
+++ b/source/rpc_parse/parse_rpc.c
@@ -3,9 +3,9 @@
  *  Unix SMB/Netbios implementation.
  *  Version 1.9.
  *  RPC Pipe client / server routines
- *  Copyright (C) Andrew Tridgell              1992-1999,
- *  Copyright (C) Luke Kenneth Casson Leighton 1996-1999,
- *  Copyright (C) Paul Ashton                  1997-1999.
+ *  Copyright (C) Andrew Tridgell              1992-2000,
+ *  Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
+ *  Copyright (C) Paul Ashton                  1997-2000.
  *  
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -28,175 +28,160 @@
 
 extern int DEBUGLEVEL;
 
-
 /*******************************************************************
 interface/version dce/rpc pipe identification
 ********************************************************************/
 
-#define TRANS_SYNT_V2             \
-{                                 \
-	{                             \
-		0x04, 0x5d, 0x88, 0x8a,   \
-		0xeb, 0x1c, 0xc9, 0x11,   \
-		0x9f, 0xe8, 0x08, 0x00,   \
-		0x2b, 0x10, 0x48, 0x60    \
-	}, 0x02                       \
-}                                 \
-
-#define SYNT_SVCCTL_V2          \
-{                                 \
-	{                             \
-		0x81, 0xbb, 0x7a, 0x36,   \
-		0x44, 0x98, 0xf1, 0x35,   \
-		0xad, 0x32, 0x98, 0xf0,   \
-		0x38, 0x00, 0x10, 0x03    \
-	}, 0x02                       \
-}                                 \
-
-#define SYNT_BROWSER_V0          \
-{                                 \
-	{                             \
-		0x98, 0xd0, 0xff, 0x6b,   \
-		0x12, 0xa1, 0x10, 0x36,   \
-		0x98, 0x33, 0x01, 0x28,   \
-		0x92, 0x02, 0x01, 0x62    \
-	}, 0x00                       \
-}                                 \
-
-#define SYNT_NETLOGON_V2          \
-{                                 \
-	{                             \
-		0x04, 0x5d, 0x88, 0x8a,   \
-		0xeb, 0x1c, 0xc9, 0x11,   \
-		0x9f, 0xe8, 0x08, 0x00,   \
-		0x2b, 0x10, 0x48, 0x60    \
-	}, 0x02                       \
-}                                 \
-
-#define SYNT_WKSSVC_V1            \
-{                                 \
-	{                             \
-		0x98, 0xd0, 0xff, 0x6b,   \
-		0x12, 0xa1, 0x10, 0x36,   \
-		0x98, 0x33, 0x46, 0xc3,   \
-		0xf8, 0x7e, 0x34, 0x5a    \
-	}, 0x01                       \
-}                                 \
-
-#define SYNT_SRVSVC_V3            \
-{                                 \
-	{                             \
-		0xc8, 0x4f, 0x32, 0x4b,   \
-		0x70, 0x16, 0xd3, 0x01,   \
-		0x12, 0x78, 0x5a, 0x47,   \
-		0xbf, 0x6e, 0xe1, 0x88    \
-	}, 0x03                       \
-}                                 \
-
-#define SYNT_LSARPC_V0            \
-{                                 \
-	{                             \
-		0x78, 0x57, 0x34, 0x12,   \
-		0x34, 0x12, 0xcd, 0xab,   \
-		0xef, 0x00, 0x01, 0x23,   \
-		0x45, 0x67, 0x89, 0xab    \
-	}, 0x00                       \
-}                                 \
-
-#define SYNT_SAMR_V1              \
-{                                 \
-	{                             \
-		0x78, 0x57, 0x34, 0x12,   \
-		0x34, 0x12, 0xcd, 0xab,   \
-		0xef, 0x00, 0x01, 0x23,   \
-		0x45, 0x67, 0x89, 0xac    \
-	}, 0x01                       \
-}                                 \
-
-#define SYNT_NETLOGON_V1          \
-{                                 \
-	{                             \
-		0x78, 0x56, 0x34, 0x12,   \
-		0x34, 0x12, 0xcd, 0xab,   \
-		0xef, 0x00, 0x01, 0x23,   \
-		0x45, 0x67, 0xcf, 0xfb    \
-	}, 0x01                       \
-}                                 \
-
-#define SYNT_WINREG_V1            \
-{                                 \
-	{                             \
-		0x01, 0xd0, 0x8c, 0x33,   \
-		0x44, 0x22, 0xf1, 0x31,   \
-		0xaa, 0xaa, 0x90, 0x00,   \
-		0x38, 0x00, 0x10, 0x03    \
-	}, 0x01                       \
-}                                 \
-
-#define SYNT_ATSVC_V1            \
-{                                 \
-	{                             \
-		0x82, 0x06, 0xf7, 0x1f,   \
-		0x51, 0x0a, 0xe8, 0x30,   \
-		0x07, 0x6d, 0x74, 0x0b,   \
-		0xe8, 0xce, 0xe9, 0x8b    \
-	}, 0x01                       \
-}                                 \
-
-#define SYNT_SPOOLSS_V1           \
-{                                 \
-	{                             \
-		0x78, 0x56, 0x34, 0x12,   \
-		0x34, 0x12, 0xcd, 0xab,   \
-		0xef, 0x00, 0x01, 0x23,   \
-		0x45, 0x67, 0x89, 0xab    \
-	}, 0x01                       \
-}                                 \
-
-#define SYNT_NONE_V0              \
-{                                 \
-	{                             \
-		0x00, 0x00, 0x00, 0x00,   \
-		0x00, 0x00, 0x00, 0x00,   \
-		0x00, 0x00, 0x00, 0x00,   \
-		0x00, 0x00, 0x00, 0x00    \
-	}, 0x00                       \
-}                                 \
-
-#define SYNT_EVENTLOG_V0            \
-{                                 \
-	{                             \
-		0xdc, 0x3f, 0x27, 0x82,   \
-		0x2a, 0xe3, 0xc3, 0x18,   \
-		0x3f, 0x78, 0x82, 0x79,   \
-		0x29, 0xdc, 0x23, 0xea    \
-	}, 0x00                       \
-}
-                                 \
-struct pipe_id_info pipe_names [] =
-{
+#define TRANS_SYNT_V2                       \
+{                                           \
+	{                                   \
+		0x8a885d04, 0x1ceb, 0x11c9, \
+		{ 0x9f, 0xe8, 0x08, 0x00,   \
+		0x2b, 0x10, 0x48, 0x60 }    \
+	}, 0x02                             \
+}
+
+#define SYNT_SVCCTL_V2                      \
+{                                           \
+	{                                   \
+		0x367abb81, 0x9844, 0x35f1, \
+		{ 0xad, 0x32, 0x98, 0xf0,   \
+		0x38, 0x00, 0x10, 0x03 }    \
+	}, 0x02                             \
+}
+
+#define SYNT_BROWSER_V0                     \
+{                                           \
+	{                                   \
+		0x6bffd098, 0xa112, 0x3610, \
+		{ 0x98, 0x33, 0x01, 0x28,   \
+		0x92, 0x02, 0x01, 0x62 }    \
+	}, 0x00                             \
+}
+
+#define SYNT_NETLOGON_V2                    \
+{                                           \
+	{                                   \
+		0x8a885d04, 0x1ceb, 0x11c9, \
+		{ 0x9f, 0xe8, 0x08, 0x00,   \
+		0x2b, 0x10, 0x48, 0x60 }    \
+	}, 0x02                             \
+}
+
+#define SYNT_WKSSVC_V1                      \
+{                                           \
+	{                                   \
+		0x6bffd098, 0xa112, 0x3610, \
+		{ 0x98, 0x33, 0x46, 0xc3,   \
+		0xf8, 0x7e, 0x34, 0x5a }    \
+	}, 0x01                             \
+}
+
+#define SYNT_SRVSVC_V3                      \
+{                                           \
+	{                                   \
+		0x4b324fc8, 0x1670, 0x01d3, \
+		{ 0x12, 0x78, 0x5a, 0x47,   \
+		0xbf, 0x6e, 0xe1, 0x88 }    \
+	}, 0x03                             \
+}
+
+#define SYNT_LSARPC_V0                      \
+{                                           \
+	{                                   \
+		0x12345778, 0x1234, 0xabcd, \
+		{ 0xef, 0x00, 0x01, 0x23,   \
+		0x45, 0x67, 0x89, 0xab }    \
+	}, 0x00                             \
+}
+
+#define SYNT_NETLOGON_V1                    \
+{                                           \
+	{                                   \
+		0x12345678, 0x1234, 0xabcd, \
+		{ 0xef, 0x00, 0x01, 0x23,   \
+		0x45, 0x67, 0xcf, 0xfb }    \
+	}, 0x01                             \
+}
+
+#define SYNT_SAMR_V1                        \
+{                                           \
+	{                                   \
+		0x12345778, 0x1234, 0xabcd, \
+		{ 0xef, 0x00, 0x01, 0x23,   \
+		0x45, 0x67, 0x89, 0xac }    \
+	}, 0x01                             \
+}
+
+#define SYNT_WINREG_V1                      \
+{                                           \
+	{                                   \
+		0x338cd001, 0x2244, 0x31f1, \
+		{ 0xaa, 0xaa, 0x90, 0x00,   \
+		0x38, 0x00, 0x10, 0x03 }    \
+	}, 0x01                             \
+}
+
+#define SYNT_ATSVC_V1                       \
+{                                           \
+	{                                   \
+		0x1ff70682, 0x0a51, 0xe830, \
+		{ 0x07, 0x6d, 0x74, 0x0b,   \
+		0xe8, 0xce, 0xe9, 0x8b }    \
+	}, 0x01                             \
+}
+
+#define SYNT_SPOOLSS_V1                     \
+{                                           \
+	{                                   \
+		0x12345678, 0x1234, 0xabcb, \
+		{ 0xef, 0x00, 0x01, 0x23,   \
+		0x45, 0x67, 0x89, 0xab }    \
+	}, 0x01                             \
+}
+
+#define SYNT_NONE_V0                        \
+{                                           \
+	{                                   \
+		0x0, 0x0, 0x0,              \
+		{ 0x00, 0x00, 0x00, 0x00,   \
+		0x00, 0x00, 0x00, 0x00 }    \
+	}, 0x00                             \
+}
+
+#define SYNT_EVENTLOG_V0                    \
+{                                           \
+	{                                   \
+		0x82273fdc, 0x2ae3, 0xc318, \
+		{ 0x3f, 0x78, 0x82, 0x79,   \
+		0x29, 0xdc, 0x23, 0xea }    \
+	}, 0x00                             \
+}
+
+struct pipe_id_info pipe_names[] = {
 	/* client pipe , abstract syntax , server pipe   , transfer syntax */
-	{ PIPE_LSARPC  , SYNT_LSARPC_V0  , PIPE_LSASS    , TRANS_SYNT_V2 },
-	{ PIPE_BROWSER , SYNT_BROWSER_V0 , PIPE_NTSVCS   , TRANS_SYNT_V2 },
-	{ PIPE_SAMR    , SYNT_SAMR_V1    , PIPE_LSASS    , TRANS_SYNT_V2 },
-	{ PIPE_NETLOGON, SYNT_NETLOGON_V1, PIPE_LSASS    , TRANS_SYNT_V2 },
-	{ PIPE_SRVSVC  , SYNT_SRVSVC_V3  , PIPE_NTSVCS   , TRANS_SYNT_V2 },
-	{ PIPE_SVCCTL  , SYNT_SVCCTL_V2  , PIPE_NTSVCS   , TRANS_SYNT_V2 },
-	{ PIPE_WKSSVC  , SYNT_WKSSVC_V1  , PIPE_NTSVCS   , TRANS_SYNT_V2 },
-	{ PIPE_WINREG  , SYNT_WINREG_V1  , PIPE_WINREG   , TRANS_SYNT_V2 },
-	{ PIPE_ATSVC   , SYNT_ATSVC_V1   , PIPE_ATSVC    , TRANS_SYNT_V2 },
-	{ PIPE_SPOOLSS , SYNT_SPOOLSS_V1 , PIPE_SPOOLSS  , TRANS_SYNT_V2 },
-	{ PIPE_EVENTLOG, SYNT_EVENTLOG_V0, PIPE_EVENTLOG , TRANS_SYNT_V2 },
-	{ NULL         , SYNT_NONE_V0    , NULL          , SYNT_NONE_V0  }
+	{PIPE_LSARPC, SYNT_LSARPC_V0, PIPE_LSASS, TRANS_SYNT_V2},
+	{PIPE_BROWSER, SYNT_BROWSER_V0, PIPE_NTSVCS, TRANS_SYNT_V2},
+	{PIPE_SAMR, SYNT_SAMR_V1, PIPE_LSASS, TRANS_SYNT_V2},
+	{PIPE_NETLOGON, SYNT_NETLOGON_V1, PIPE_LSASS, TRANS_SYNT_V2},
+	{PIPE_SRVSVC, SYNT_SRVSVC_V3, PIPE_NTSVCS, TRANS_SYNT_V2},
+	{PIPE_SVCCTL, SYNT_SVCCTL_V2, PIPE_NTSVCS, TRANS_SYNT_V2},
+	{PIPE_WKSSVC, SYNT_WKSSVC_V1, PIPE_NTSVCS, TRANS_SYNT_V2},
+	{PIPE_WINREG, SYNT_WINREG_V1, PIPE_WINREG, TRANS_SYNT_V2},
+	{PIPE_ATSVC, SYNT_ATSVC_V1, PIPE_ATSVC, TRANS_SYNT_V2},
+	{PIPE_SPOOLSS, SYNT_SPOOLSS_V1, PIPE_SPOOLSS, TRANS_SYNT_V2},
+	{PIPE_EVENTLOG, SYNT_EVENTLOG_V0, PIPE_EVENTLOG, TRANS_SYNT_V2},
+	{NULL, SYNT_NONE_V0, NULL, SYNT_NONE_V0}
 };
 
 /*******************************************************************
 creates an RPC_HDR structure.
 ********************************************************************/
-BOOL make_rpc_hdr(RPC_HDR *hdr, enum RPC_PKT_TYPE pkt_type, uint8 flags,
-				uint32 call_id, int data_len, int auth_len)
+BOOL make_rpc_hdr(RPC_HDR * hdr, enum RPC_PKT_TYPE pkt_type, uint8 flags,
+		  uint32 call_id, int frag_len, int auth_len)
 {
-	if (hdr == NULL) return False;
+	if (hdr == NULL)
+		return False;
 
 	hdr->major        = 5;               /* RPC version 5 */
 	hdr->minor        = 0;               /* minor version 0 */
@@ -206,7 +191,7 @@ BOOL make_rpc_hdr(RPC_HDR *hdr, enum RPC_PKT_TYPE pkt_type, uint8 flags,
 	hdr->pack_type[1] = 0x0;             /* packed data representation */
 	hdr->pack_type[2] = 0x0;             /* packed data representation */
 	hdr->pack_type[3] = 0x0;             /* packed data representation */
-	hdr->frag_len     = data_len;        /* fragment length, fill in later */
+	hdr->frag_len     = frag_len;        /* fragment length, fill in later */
 	hdr->auth_len     = auth_len;        /* authentication length */
 	hdr->call_id      = call_id;         /* call identifier - match incoming RPC */
 
@@ -216,24 +201,22 @@ BOOL make_rpc_hdr(RPC_HDR *hdr, enum RPC_PKT_TYPE pkt_type, uint8 flags,
 /*******************************************************************
 reads or writes an RPC_HDR structure.
 ********************************************************************/
-BOOL smb_io_rpc_hdr(char *desc,  RPC_HDR *rpc, prs_struct *ps, int depth)
+BOOL smb_io_rpc_hdr(char *desc, RPC_HDR * rpc, prs_struct * ps, int depth)
 {
-	if (rpc == NULL) return False;
+	if (rpc == NULL)
+		return False;
 
 	prs_debug(ps, depth, desc, "smb_io_rpc_hdr");
 	depth++;
 
-	prs_uint8 ("major     ", ps, depth, &rpc->major);
-	prs_uint8 ("minor     ", ps, depth, &rpc->minor);
-	prs_uint8 ("pkt_type  ", ps, depth, &rpc->pkt_type);
-	prs_uint8 ("flags     ", ps, depth, &rpc->flags);
+	prs_uint8("major     ", ps, depth, &rpc->major);
+	prs_uint8("minor     ", ps, depth, &rpc->minor);
+	prs_uint8("pkt_type  ", ps, depth, &rpc->pkt_type);
+	prs_uint8("flags     ", ps, depth, &rpc->flags);
 	prs_uint8s(False, "pack_type ", ps, depth, rpc->pack_type,
-	                                           sizeof(rpc->pack_type));
-	if (ps->io)
-	{
-		/* reading - set packed data representation type */
-		prs_set_packtype(ps, rpc->pack_type);
-	}
+		   sizeof(rpc->pack_type));
+
+	prs_set_packtype(ps, rpc->pack_type);
 
 	prs_uint16("frag_len  ", ps, depth, &rpc->frag_len);
 	prs_uint16("auth_len  ", ps, depth, &rpc->auth_len);
@@ -245,38 +228,41 @@ BOOL smb_io_rpc_hdr(char *desc,  RPC_HDR *rpc, prs_struct *ps, int depth)
 /*******************************************************************
 checks a PDU structure.
 ********************************************************************/
-BOOL is_complete_pdu(prs_struct *ps)
+BOOL is_complete_pdu(prs_struct * ps)
 {
 	RPC_HDR hdr;
 	int len = ps->data_size;
 
-	DEBUG(10,("is_complete_pdu - len %d\n", len));
+	DEBUG(10, ("is_complete_pdu - len %d\n", len));
 	ps->offset = 0x0;
 
 	if (!ps->io)
 	{
 		/* writing.  oops!! */
-		DEBUG(4,("is_complete_pdu: write set, not read!\n"));
+		DEBUG(4, ("is_complete_pdu: write set, not read!\n"));
 		return False;
 	}
-		
+
 	if (!smb_io_rpc_hdr("hdr", &hdr, ps, 0))
 	{
 		return False;
 	}
 
-	DEBUG(10,("is_complete_pdu - frag_len %d\n", hdr.frag_len));
+	DEBUG(10, ("is_complete_pdu - frag_len %d\n", hdr.frag_len));
 
 	/* check that the fragment length is equal to the data length so far */
 	return hdr.frag_len == len;
 }
 
 /*******************************************************************
+<<<<<<< parse_rpc.c
 reads or writes an RPC_HDR_NACK structure.
 ********************************************************************/
-BOOL smb_io_rpc_hdr_nack(char *desc,  RPC_HDR_NACK *rpc, prs_struct *ps, int depth)
+BOOL smb_io_rpc_hdr_nack(char *desc, RPC_HDR_NACK * rpc, prs_struct * ps,
+			 int depth)
 {
-	if (rpc == NULL) return False;
+	if (rpc == NULL)
+		return False;
 
 	prs_debug(ps, depth, desc, "smb_io_rpc_hdr_nack");
 	depth++;
@@ -289,33 +275,42 @@ BOOL smb_io_rpc_hdr_nack(char *desc,  RPC_HDR_NACK *rpc, prs_struct *ps, int dep
 /*******************************************************************
 reads or writes an RPC_HDR_FAULT structure.
 ********************************************************************/
-BOOL smb_io_rpc_hdr_fault(char *desc,  RPC_HDR_FAULT *rpc, prs_struct *ps, int depth)
+BOOL smb_io_rpc_hdr_fault(char *desc, RPC_HDR_FAULT * rpc, prs_struct * ps,
+			  int depth)
 {
-	if (rpc == NULL) return False;
+	if (rpc == NULL)
+		return False;
 
 	prs_debug(ps, depth, desc, "smb_io_rpc_hdr_fault");
 	depth++;
 
-	prs_uint32("status  ", ps, depth, &(rpc->status  ));
+	prs_uint32("status  ", ps, depth, &(rpc->status));
 	prs_uint32("reserved", ps, depth, &(rpc->reserved));
 
 	return True;
 }
 
 /*******************************************************************
-reads or writes an RPC_IFACE structure.
+ Reads or writes an RPC_IFACE structure.
 ********************************************************************/
-static BOOL smb_io_rpc_iface(char *desc,  RPC_IFACE *ifc, prs_struct *ps, int depth)
+static BOOL smb_io_rpc_iface(char *desc, RPC_IFACE * ifc, prs_struct * ps,
+			     int depth)
 {
-	if (ifc == NULL) return False;
+	if (ifc == NULL)
+		return False;
 
 	prs_debug(ps, depth, desc, "smb_io_rpc_iface");
 	depth++;
 
 	prs_align(ps);
 
-	prs_uint8s (False, "data   ", ps, depth, ifc->data, sizeof(ifc->data));
-	prs_uint32 (       "version", ps, depth, &(ifc->version));
+	prs_uint32("time_low", ps, depth, &ifc->uuid.time_low);
+	prs_uint16("time_mid", ps, depth, &ifc->uuid.time_mid);
+	prs_uint16("time_hiv", ps, depth, &ifc->uuid.time_hi_and_version);
+
+	prs_uint8s(False, "uuid   ", ps, depth, ifc->uuid.remaining,
+		   sizeof(ifc->uuid.remaining));
+	prs_uint32("version", ps, depth, &ifc->version);
 
 	return True;
 }
@@ -325,9 +320,10 @@ creates an RPC_ADDR_STR structure.
 
 The name can be null (RPC Alter-Context)
 ********************************************************************/
-static BOOL make_rpc_addr_str(RPC_ADDR_STR *str, const char *name)
+static BOOL make_rpc_addr_str(RPC_ADDR_STR * str, const char *name)
 {
-	if (str == NULL ) return False;
+	if (str == NULL)
+		return False;
 	if (name == NULL)
 	{
 		str->len = 1;
@@ -345,16 +341,18 @@ static BOOL make_rpc_addr_str(RPC_ADDR_STR *str, const char *name)
 /*******************************************************************
 reads or writes an RPC_ADDR_STR structure.
 ********************************************************************/
-static BOOL smb_io_rpc_addr_str(char *desc,  RPC_ADDR_STR *str, prs_struct *ps, int depth)
+static BOOL smb_io_rpc_addr_str(char *desc, RPC_ADDR_STR * str,
+				prs_struct * ps, int depth)
 {
-	if (str == NULL) return False;
+	if (str == NULL)
+		return False;
 
 	prs_debug(ps, depth, desc, "smb_io_rpc_addr_str");
 	depth++;
 	prs_align(ps);
 
-	prs_uint16 (      "len", ps, depth, &(str->len));
-	prs_uint8s (True, "str", ps, depth, (uchar*)str->str, str->len);
+	prs_uint16("len", ps, depth, &(str->len));
+	prs_uint8s(True, "str", ps, depth, (uchar *) str->str, str->len);
 
 	return True;
 }
@@ -362,13 +360,15 @@ static BOOL smb_io_rpc_addr_str(char *desc,  RPC_ADDR_STR *str, prs_struct *ps,
 /*******************************************************************
 creates an RPC_HDR_BBA structure.
 ********************************************************************/
-static BOOL make_rpc_hdr_bba(RPC_HDR_BBA *bba, uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid)
+static BOOL make_rpc_hdr_bba(RPC_HDR_BBA * bba, uint16 max_tsize,
+			     uint16 max_rsize, uint32 assoc_gid)
 {
-	if (bba == NULL) return False;
+	if (bba == NULL)
+		return False;
 
-	bba->max_tsize = max_tsize; /* maximum transmission fragment size (0x1630) */
-	bba->max_rsize = max_rsize; /* max receive fragment size (0x1630) */   
-	bba->assoc_gid = assoc_gid; /* associated group id (0x0) */ 
+	bba->max_tsize = max_tsize;	/* maximum transmission fragment size (0x1630) */
+	bba->max_rsize = max_rsize;	/* max receive fragment size (0x1630) */
+	bba->assoc_gid = assoc_gid;	/* associated group id (0x0) */
 
 	return True;
 }
@@ -376,9 +376,11 @@ static BOOL make_rpc_hdr_bba(RPC_HDR_BBA *bba, uint16 max_tsize, uint16 max_rsiz
 /*******************************************************************
 reads or writes an RPC_HDR_BBA structure.
 ********************************************************************/
-static BOOL smb_io_rpc_hdr_bba(char *desc,  RPC_HDR_BBA *rpc, prs_struct *ps, int depth)
+static BOOL smb_io_rpc_hdr_bba(char *desc, RPC_HDR_BBA * rpc, prs_struct * ps,
+			       int depth)
 {
-	if (rpc == NULL) return False;
+	if (rpc == NULL)
+		return False;
 
 	prs_debug(ps, depth, desc, "smb_io_rpc_hdr_bba");
 	depth++;
@@ -393,18 +395,20 @@ static BOOL smb_io_rpc_hdr_bba(char *desc,  RPC_HDR_BBA *rpc, prs_struct *ps, in
 /*******************************************************************
 creates an RPC_HDR_RB structure.
 ********************************************************************/
-BOOL make_rpc_hdr_rb(RPC_HDR_RB *rpc, 
-				uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid,
-				uint32 num_elements, uint16 context_id, uint8 num_syntaxes,
-				RPC_IFACE *abstract, RPC_IFACE *transfer)
+BOOL make_rpc_hdr_rb(RPC_HDR_RB * rpc,
+		     uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid,
+		     uint32 num_elements, uint16 context_id,
+		     uint8 num_syntaxes, RPC_IFACE * abstract,
+		     RPC_IFACE * transfer)
 {
-	if (rpc == NULL) return False;
+	if (rpc == NULL)
+		return False;
 
 	make_rpc_hdr_bba(&(rpc->bba), max_tsize, max_rsize, assoc_gid);
 
-	rpc->num_elements = num_elements ; /* the number of elements (0x1) */
-	rpc->context_id   = context_id   ; /* presentation context identifier (0x0) */
-	rpc->num_syntaxes = num_syntaxes ; /* the number of syntaxes (has always been 1?)(0x1) */
+	rpc->num_elements = num_elements;	/* the number of elements (0x1) */
+	rpc->context_id = context_id;	/* presentation context identifier (0x0) */
+	rpc->num_syntaxes = num_syntaxes;	/* the number of syntaxes (has always been 1?)(0x1) */
 
 	/* num and vers. of interface client is using */
 	memcpy(&(rpc->abstract), abstract, sizeof(rpc->abstract));
@@ -418,9 +422,11 @@ BOOL make_rpc_hdr_rb(RPC_HDR_RB *rpc,
 /*******************************************************************
 reads or writes an RPC_HDR_RB structure.
 ********************************************************************/
-BOOL smb_io_rpc_hdr_rb(char *desc,  RPC_HDR_RB *rpc, prs_struct *ps, int depth)
+BOOL smb_io_rpc_hdr_rb(char *desc, RPC_HDR_RB * rpc, prs_struct * ps,
+		       int depth)
 {
-	if (rpc == NULL) return False;
+	if (rpc == NULL)
+		return False;
 
 	prs_debug(ps, depth, desc, "smb_io_rpc_hdr_rb");
 	depth++;
@@ -428,8 +434,8 @@ BOOL smb_io_rpc_hdr_rb(char *desc,  RPC_HDR_RB *rpc, prs_struct *ps, int depth)
 	smb_io_rpc_hdr_bba("", &(rpc->bba), ps, depth);
 
 	prs_uint32("num_elements", ps, depth, &(rpc->num_elements));
-	prs_uint16("context_id  ", ps, depth, &(rpc->context_id  ));
-	prs_uint8 ("num_syntaxes", ps, depth, &(rpc->num_syntaxes));
+	prs_uint16("context_id  ", ps, depth, &(rpc->context_id));
+	prs_uint8("num_syntaxes", ps, depth, &(rpc->num_syntaxes));
 
 	smb_io_rpc_iface("", &(rpc->abstract), ps, depth);
 	smb_io_rpc_iface("", &(rpc->transfer), ps, depth);
@@ -443,14 +449,15 @@ creates an RPC_RESULTS structure.
 lkclXXXX only one reason at the moment!
 
 ********************************************************************/
-static BOOL make_rpc_results(RPC_RESULTS *res, 
-				uint8 num_results, uint16 result, uint16 reason)
+static BOOL make_rpc_results(RPC_RESULTS * res,
+			     uint8 num_results, uint16 result, uint16 reason)
 {
-	if (res == NULL) return False;
+	if (res == NULL)
+		return False;
 
-	res->num_results = num_results; /* the number of results (0x01) */
-	res->result      = result     ;  /* result (0x00 = accept) */
-	res->reason      = reason     ;  /* reason (0x00 = no reason specified) */
+	res->num_results = num_results;	/* the number of results (0x01) */
+	res->result = result;	/* result (0x00 = accept) */
+	res->reason = reason;	/* reason (0x00 = no reason specified) */
 
 	return True;
 }
@@ -461,21 +468,23 @@ reads or writes an RPC_RESULTS structure.
 lkclXXXX only one reason at the moment!
 
 ********************************************************************/
-static BOOL smb_io_rpc_results(char *desc,  RPC_RESULTS *res, prs_struct *ps, int depth)
+static BOOL smb_io_rpc_results(char *desc, RPC_RESULTS * res, prs_struct * ps,
+			       int depth)
 {
-	if (res == NULL) return False;
+	if (res == NULL)
+		return False;
 
 	prs_debug(ps, depth, desc, "smb_io_rpc_results");
 	depth++;
 
 	prs_align(ps);
-	
-	prs_uint8 ("num_results", ps, depth, &(res->num_results));
+
+	prs_uint8("num_results", ps, depth, &(res->num_results));
 
 	prs_align(ps);
-	
-	prs_uint16("result     ", ps, depth, &(res->result     ));
-	prs_uint16("reason     ", ps, depth, &(res->reason     ));
+
+	prs_uint16("result     ", ps, depth, &(res->result));
+	prs_uint16("reason     ", ps, depth, &(res->reason));
 
 	return True;
 }
@@ -487,17 +496,18 @@ lkclXXXX only one reason at the moment!
 jfm: nope two ! The pipe_addr can be NULL !
 
 ********************************************************************/
-BOOL make_rpc_hdr_ba(RPC_HDR_BA *rpc, 
-				uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid,
-				const char *pipe_addr,
-				uint8 num_results, uint16 result, uint16 reason,
-				RPC_IFACE *transfer)
+BOOL make_rpc_hdr_ba(RPC_HDR_BA * rpc,
+		     uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid,
+		     const char *pipe_addr,
+		     uint8 num_results, uint16 result, uint16 reason,
+		     RPC_IFACE * transfer)
 {
-	if (rpc == NULL || transfer == NULL) return False;
+	if (rpc == NULL || transfer == NULL)
+		return False;
 
-	make_rpc_hdr_bba (&(rpc->bba ), max_tsize, max_rsize, assoc_gid);
+	make_rpc_hdr_bba(&(rpc->bba), max_tsize, max_rsize, assoc_gid);
 	make_rpc_addr_str(&(rpc->addr), pipe_addr);
-	make_rpc_results (&(rpc->res ), num_results, result, reason);
+	make_rpc_results(&(rpc->res), num_results, result, reason);
 
 	/* the transfer syntax from the request */
 	memcpy(&(rpc->transfer), transfer, sizeof(rpc->transfer));
@@ -508,17 +518,19 @@ BOOL make_rpc_hdr_ba(RPC_HDR_BA *rpc,
 /*******************************************************************
 reads or writes an RPC_HDR_BA structure.
 ********************************************************************/
-BOOL smb_io_rpc_hdr_ba(char *desc,  RPC_HDR_BA *rpc, prs_struct *ps, int depth)
+BOOL smb_io_rpc_hdr_ba(char *desc, RPC_HDR_BA * rpc, prs_struct * ps,
+		       int depth)
 {
-	if (rpc == NULL) return False;
+	if (rpc == NULL)
+		return False;
 
 	prs_debug(ps, depth, desc, "smb_io_rpc_hdr_ba");
 	depth++;
 
-	smb_io_rpc_hdr_bba ("", &(rpc->bba)     , ps, depth);
-	smb_io_rpc_addr_str("", &(rpc->addr)    , ps, depth);
-	smb_io_rpc_results ("", &(rpc->res)     , ps, depth);
-	smb_io_rpc_iface   ("", &(rpc->transfer), ps, depth);
+	smb_io_rpc_hdr_bba("", &(rpc->bba), ps, depth);
+	smb_io_rpc_addr_str("", &(rpc->addr), ps, depth);
+	smb_io_rpc_results("", &(rpc->res), ps, depth);
+	smb_io_rpc_iface("", &(rpc->transfer), ps, depth);
 
 	return True;
 }
@@ -526,14 +538,15 @@ BOOL smb_io_rpc_hdr_ba(char *desc,  RPC_HDR_BA *rpc, prs_struct *ps, int depth)
 /*******************************************************************
 creates an RPC_HDR_REQ structure.
 ********************************************************************/
-BOOL make_rpc_hdr_req(RPC_HDR_REQ *hdr, uint32 alloc_hint, uint16 vuid,
-				uint16 opnum)
+BOOL make_rpc_hdr_req(RPC_HDR_REQ * hdr, uint32 alloc_hint, uint16 vuid,
+		      uint16 opnum)
 {
-	if (hdr == NULL) return False;
+	if (hdr == NULL)
+		return False;
 
-	hdr->alloc_hint   = alloc_hint; /* allocation hint */
-	hdr->context_id   = vuid;         /* presentation context identifier */
-	hdr->opnum        = opnum;     /* opnum */
+	hdr->alloc_hint = alloc_hint;	/* allocation hint */
+	hdr->context_id = vuid;	/* presentation context identifier */
+	hdr->opnum = opnum;	/* opnum */
 
 	return True;
 }
@@ -541,9 +554,11 @@ BOOL make_rpc_hdr_req(RPC_HDR_REQ *hdr, uint32 alloc_hint, uint16 vuid,
 /*******************************************************************
 reads or writes an RPC_HDR_REQ structure.
 ********************************************************************/
-BOOL smb_io_rpc_hdr_req(char *desc,  RPC_HDR_REQ *rpc, prs_struct *ps, int depth)
+BOOL smb_io_rpc_hdr_req(char *desc, RPC_HDR_REQ * rpc, prs_struct * ps,
+			int depth)
 {
-	if (rpc == NULL) return False;
+	if (rpc == NULL)
+		return False;
 
 	prs_debug(ps, depth, desc, "smb_io_rpc_hdr_req");
 	depth++;
@@ -558,17 +573,19 @@ BOOL smb_io_rpc_hdr_req(char *desc,  RPC_HDR_REQ *rpc, prs_struct *ps, int depth
 /*******************************************************************
 reads or writes an RPC_HDR_RESP structure.
 ********************************************************************/
-BOOL smb_io_rpc_hdr_resp(char *desc,  RPC_HDR_RESP *rpc, prs_struct *ps, int depth)
+BOOL smb_io_rpc_hdr_resp(char *desc, RPC_HDR_RESP * rpc, prs_struct * ps,
+			 int depth)
 {
-	if (rpc == NULL) return False;
+	if (rpc == NULL)
+		return False;
 
 	prs_debug(ps, depth, desc, "smb_io_rpc_hdr_resp");
 	depth++;
 
 	prs_uint32("alloc_hint", ps, depth, &(rpc->alloc_hint));
 	prs_uint16("context_id", ps, depth, &(rpc->context_id));
-	prs_uint8 ("cancel_ct ", ps, depth, &(rpc->cancel_count));
-	prs_uint8 ("reserved  ", ps, depth, &(rpc->reserved));
+	prs_uint8("cancel_ct ", ps, depth, &(rpc->cancel_count));
+	prs_uint8("reserved  ", ps, depth, &(rpc->reserved));
 
 	return True;
 }
@@ -576,22 +593,23 @@ BOOL smb_io_rpc_hdr_resp(char *desc,  RPC_HDR_RESP *rpc, prs_struct *ps, int dep
 /*******************************************************************
 creates an RPC_HDR_AUTHA structure.
 ********************************************************************/
-BOOL make_rpc_hdr_autha(RPC_HDR_AUTHA *rai,
-				uint16 max_tsize, uint16 max_rsize,
-				uint8 auth_type, uint8 auth_level,
-				uint8 stub_type_len)
+BOOL make_rpc_hdr_autha(RPC_HDR_AUTHA * rai,
+			uint16 max_tsize, uint16 max_rsize,
+			uint8 auth_type, uint8 auth_level,
+			uint8 stub_type_len)
 {
-	if (rai == NULL) return False;
+	if (rai == NULL)
+		return False;
 
-	rai->max_tsize = max_tsize; /* maximum transmission fragment size (0x1630) */
-	rai->max_rsize = max_rsize; /* max receive fragment size (0x1630) */   
+	rai->max_tsize = max_tsize;	/* maximum transmission fragment size (0x1630) */
+	rai->max_rsize = max_rsize;	/* max receive fragment size (0x1630) */
 
-	rai->auth_type     = auth_type; /* nt lm ssp 0x0a */
-	rai->auth_level    = auth_level; /* 0x06 */
-	rai->stub_type_len = stub_type_len; /* 0x00 */
-	rai->padding       = 0; /* padding 0x00 */
+	rai->auth_type = auth_type;	/* nt lm ssp 0x0a */
+	rai->auth_level = auth_level;	/* 0x06 */
+	rai->stub_type_len = stub_type_len;	/* 0x00 */
+	rai->padding = 0;	/* padding 0x00 */
 
-	rai->unknown       = 0x0014a0c0; /* non-zero pointer to something */
+	rai->unknown = 0x0014a0c0;	/* non-zero pointer to something */
 
 	return True;
 }
@@ -599,9 +617,11 @@ BOOL make_rpc_hdr_autha(RPC_HDR_AUTHA *rai,
 /*******************************************************************
 reads or writes an RPC_HDR_AUTHA structure.
 ********************************************************************/
-BOOL smb_io_rpc_hdr_autha(char *desc, RPC_HDR_AUTHA *rai, prs_struct *ps, int depth)
+BOOL smb_io_rpc_hdr_autha(char *desc, RPC_HDR_AUTHA * rai, prs_struct * ps,
+			  int depth)
 {
-	if (rai == NULL) return False;
+	if (rai == NULL)
+		return False;
 
 	prs_debug(ps, depth, desc, "smb_io_rpc_hdr_autha");
 	depth++;
@@ -609,12 +629,12 @@ BOOL smb_io_rpc_hdr_autha(char *desc, RPC_HDR_AUTHA *rai, prs_struct *ps, int de
 	prs_uint16("max_tsize    ", ps, depth, &(rai->max_tsize));
 	prs_uint16("max_rsize    ", ps, depth, &(rai->max_rsize));
 
-	prs_uint8 ("auth_type    ", ps, depth, &(rai->auth_type    )); /* 0x0a nt lm ssp */
-	prs_uint8 ("auth_level   ", ps, depth, &(rai->auth_level   ));/* 0x06 */
-	prs_uint8 ("stub_type_len", ps, depth, &(rai->stub_type_len));
-	prs_uint8 ("padding      ", ps, depth, &(rai->padding      ));
+	prs_uint8("auth_type    ", ps, depth, &(rai->auth_type));	/* 0x0a nt lm ssp */
+	prs_uint8("auth_level   ", ps, depth, &(rai->auth_level));	/* 0x06 */
+	prs_uint8("stub_type_len", ps, depth, &(rai->stub_type_len));
+	prs_uint8("padding      ", ps, depth, &(rai->padding));
 
-	prs_uint32("unknown      ", ps, depth, &(rai->unknown      )); /* 0x0014a0c0 */
+	prs_uint32("unknown      ", ps, depth, &(rai->unknown));	/* 0x0014a0c0 */
 
 	return True;
 }
@@ -622,19 +642,19 @@ BOOL smb_io_rpc_hdr_autha(char *desc, RPC_HDR_AUTHA *rai, prs_struct *ps, int de
 /*******************************************************************
 creates an RPC_HDR_AUTH structure.
 ********************************************************************/
-BOOL make_rpc_hdr_auth(RPC_HDR_AUTH *rai,
-				uint8 auth_type, uint8 auth_level,
-				uint8 stub_type_len,
-				uint32 ptr)
+BOOL make_rpc_hdr_auth(RPC_HDR_AUTH * rai,
+		       uint8 auth_type, uint8 auth_level,
+		       uint8 stub_type_len, uint32 ptr)
 {
-	if (rai == NULL) return False;
+	if (rai == NULL)
+		return False;
 
-	rai->auth_type     = auth_type; /* nt lm ssp 0x0a */
-	rai->auth_level    = auth_level; /* 0x06 */
-	rai->stub_type_len = stub_type_len; /* 0x00 */
-	rai->padding       = 0; /* padding 0x00 */
+	rai->auth_type = auth_type;	/* nt lm ssp 0x0a */
+	rai->auth_level = auth_level;	/* 0x06 */
+	rai->stub_type_len = stub_type_len;	/* 0x00 */
+	rai->padding = 0;	/* padding 0x00 */
 
-	rai->unknown       = ptr; /* non-zero pointer to something */
+	rai->unknown = ptr;	/* non-zero pointer to something */
 
 	return True;
 }
@@ -642,19 +662,21 @@ BOOL make_rpc_hdr_auth(RPC_HDR_AUTH *rai,
 /*******************************************************************
 reads or writes an RPC_HDR_AUTH structure.
 ********************************************************************/
-BOOL smb_io_rpc_hdr_auth(char *desc, RPC_HDR_AUTH *rai, prs_struct *ps, int depth)
+BOOL smb_io_rpc_hdr_auth(char *desc, RPC_HDR_AUTH * rai, prs_struct * ps,
+			 int depth)
 {
-	if (rai == NULL) return False;
+	if (rai == NULL)
+		return False;
 
 	prs_debug(ps, depth, desc, "smb_io_rpc_hdr_auth");
 	depth++;
 
-	prs_uint8 ("auth_type    ", ps, depth, &(rai->auth_type    )); /* 0x0a nt lm ssp */
-	prs_uint8 ("auth_level   ", ps, depth, &(rai->auth_level   ));/* 0x06 */
-	prs_uint8 ("stub_type_len", ps, depth, &(rai->stub_type_len));
-	prs_uint8 ("padding      ", ps, depth, &(rai->padding      ));
+	prs_uint8("auth_type    ", ps, depth, &(rai->auth_type));	/* 0x0a nt lm ssp */
+	prs_uint8("auth_level   ", ps, depth, &(rai->auth_level));	/* 0x06 */
+	prs_uint8("stub_type_len", ps, depth, &(rai->stub_type_len));
+	prs_uint8("padding      ", ps, depth, &(rai->padding));
 
-	prs_uint32("unknown      ", ps, depth, &(rai->unknown      )); /* 0x0014a0c0 */
+	prs_uint32("unknown      ", ps, depth, &(rai->unknown));	/* 0x0014a0c0 */
 
 	return True;
 }
@@ -662,12 +684,13 @@ BOOL smb_io_rpc_hdr_auth(char *desc, RPC_HDR_AUTH *rai, prs_struct *ps, int dept
 /*******************************************************************
 creates an RPC_AUTH_VERIFIER structure.
 ********************************************************************/
-BOOL make_rpc_auth_verifier(RPC_AUTH_VERIFIER *rav,
-				char *signature, uint32 msg_type)
+BOOL make_rpc_auth_verifier(RPC_AUTH_VERIFIER * rav,
+			    char *signature, uint32 msg_type)
 {
-	if (rav == NULL) return False;
+	if (rav == NULL)
+		return False;
 
-	fstrcpy(rav->signature, signature); 
+	fstrcpy(rav->signature, signature);
 	rav->msg_type = msg_type;
 
 	return True;
@@ -676,16 +699,19 @@ BOOL make_rpc_auth_verifier(RPC_AUTH_VERIFIER *rav,
 /*******************************************************************
 reads or writes an RPC_AUTH_VERIFIER structure.
 ********************************************************************/
-BOOL smb_io_rpc_auth_verifier(char *desc, RPC_AUTH_VERIFIER *rav, prs_struct *ps, int depth)
+BOOL smb_io_rpc_auth_verifier(char *desc, RPC_AUTH_VERIFIER * rav,
+			      prs_struct * ps, int depth)
 {
-	if (rav == NULL) return False;
+	if (rav == NULL)
+		return False;
 
 	prs_debug(ps, depth, desc, "smb_io_rpc_auth_verifier");
 	depth++;
 
-	prs_string("signature", ps, depth, rav->signature, 0, sizeof(rav->signature));
+	prs_string("signature", ps, depth, rav->signature, 0,
+		   sizeof(rav->signature));
 	prs_align(ps);
-	prs_uint32("msg_type ", ps, depth, &(rav->msg_type  )); 
+	prs_uint32("msg_type ", ps, depth, &(rav->msg_type));
 
 	return True;
 }
@@ -693,9 +719,9 @@ BOOL smb_io_rpc_auth_verifier(char *desc, RPC_AUTH_VERIFIER *rav, prs_struct *ps
 /*******************************************************************
 checks an RPC_AUTH_VERIFIER structure.
 ********************************************************************/
-BOOL rpc_auth_verifier_chk(RPC_AUTH_VERIFIER *rav,
-				char *signature, uint32 msg_type)
+BOOL rpc_auth_verifier_chk(RPC_AUTH_VERIFIER * rav,
+			   char *signature, uint32 msg_type)
 {
-	return (strequal(rav->signature, signature) &&
-	        rav->msg_type == msg_type);
+	return (strequal(rav->signature, signature)
+		&& rav->msg_type == msg_type);
 }
diff --git a/source/rpc_server/srv_pipe_netsec.c b/source/rpc_server/srv_pipe_netsec.c
index 33534502236..00aaab0fbd3 100644
--- a/source/rpc_server/srv_pipe_netsec.c
+++ b/source/rpc_server/srv_pipe_netsec.c
@@ -33,10 +33,10 @@ this is where the data really should be split up into an array of
 headers and data sections.
 
 ********************************************************************/
-static BOOL api_netsec_create_pdu(rpcsrv_struct *l, uint32 data_start,
-				prs_struct *resp)
+static BOOL api_netsec_create_pdu(rpcsrv_struct * l, uint32 data_start,
+				  prs_struct * resp)
 {
-	netsec_auth_struct *a = (netsec_auth_struct *)l->auth_info;
+	netsec_auth_struct *a = (netsec_auth_struct *) l->auth_info;
 
 	BOOL ret;
 	uint32 data_len;
@@ -44,78 +44,85 @@ static BOOL api_netsec_create_pdu(rpcsrv_struct *l, uint32 data_start,
 	uint32 auth_len;
 	uint32 data_end = l->rdata.offset + 8 + 0x20;
 	char *data;
+	uint8 flags;
+	uint32 call_id = l->hdr.call_id;
 
 	prs_struct rhdr;
 	prs_struct rdata_i;
 	prs_struct rauth;
 	prs_struct rverf;
 
-	RPC_HDR_RESP  hdr_resp;
-	RPC_HDR_AUTH  auth_info;
+	RPC_HDR_RESP hdr_resp;
+	RPC_HDR_AUTH auth_info;
 	RPC_AUTH_NETSEC_CHK verf;
 	uchar sign[8];
 	static const uchar netsec_sig[8] = NETSEC_SIGNATURE;
 
-	DEBUG(5,("api_netsec_create_pdu: data_start: %d data_end: %d max_tsize: %d\n",
-	          data_start, data_end, l->hdr_ba.bba.max_tsize));
+	DEBUG(5,
+	      ("api_netsec_create_pdu: data_start: %d data_end: %d max_tsize: %d\n",
+	       data_start, data_end, l->hdr_ba.bba.max_tsize));
 
 	auth_len = l->hdr.auth_len;
 
-	DEBUG(10,("api_netsec_create_pdu: auth\n"));
+	DEBUG(10, ("api_netsec_create_pdu: auth\n"));
 
 	if (auth_len != 0x20)
 	{
 		return False;
 	}
 
-	prs_init(&rhdr , 0, 4, False);
-
-	l->hdr.pkt_type = RPC_RESPONSE; /* mark header as an rpc response */
+	prs_init(&rhdr, 0, 4, False);
 
 	/* set up rpc header (fragmentation issues) */
 	if (data_start == 0)
 	{
-		l->hdr.flags = RPC_FLG_FIRST;
+		flags = RPC_FLG_FIRST;
 	}
 	else
 	{
-		l->hdr.flags = 0;
+		flags = 0;
 	}
 
-	hdr_resp.alloc_hint = data_end - data_start; /* calculate remaining data to be sent */
+	hdr_resp.alloc_hint = data_end - data_start;	/* calculate remaining data to be sent */
 	hdr_resp.cancel_count = 0x0;
-	hdr_resp.context_id   = 0x0;
-	hdr_resp.reserved     = 0x0;
+	hdr_resp.context_id = 0x0;
+	hdr_resp.reserved = 0x0;
 
-	DEBUG(10,("alloc_hint: %d\n", hdr_resp.alloc_hint));
+	DEBUG(10, ("alloc_hint: %d\n", hdr_resp.alloc_hint));
 
 	if (hdr_resp.alloc_hint + 0x18 <= l->hdr_ba.bba.max_tsize)
 	{
-		l->hdr.flags |= RPC_FLG_LAST;
-		l->hdr.frag_len = hdr_resp.alloc_hint + 0x18;
+		flags |= RPC_FLG_LAST;
+		frag_len = hdr_resp.alloc_hint + 0x18;
 	}
 	else
 	{
-		l->hdr.frag_len = l->hdr_ba.bba.max_tsize;
+		frag_len = l->hdr_ba.bba.max_tsize;
 	}
 
 	hdr_resp.alloc_hint -= auth_len + 8;
 
-	data_len = l->hdr.frag_len - auth_len - 8 - 0x18;
+	data_len = frag_len - auth_len - 8 - 0x18;
 
 	rhdr.start = 0;
-	rhdr.end   = 0x18;
+	rhdr.end = 0x18;
+
+	DEBUG(10, ("hdr flags: %x\n", flags));
 
-	DEBUG(10,("hdr flags: %x\n", l->hdr.flags));
+	if (!make_rpc_hdr(&l->hdr, RPC_RESPONSE, flags, call_id,
+			  frag_len, auth_len))
+	{
+		return False;
+	}
 
 	/* store the header in the data stream */
-	smb_io_rpc_hdr     ("rhdr", &(l->hdr  ), &rhdr, 0);
+	smb_io_rpc_hdr("rhdr", &(l->hdr), &rhdr, 0);
 	smb_io_rpc_hdr_resp("resp", &(hdr_resp), &rhdr, 0);
 
 	/* don't use rdata: use rdata_i instead, which moves... */
 	/* make a pointer to the rdata data, NOT A COPY */
 	data = prs_data(&l->rdata, data_start);
-	prs_create(&rdata_i, data, data_len, l->rdata.align, rdata_i.io); 
+	prs_create(&rdata_i, data, data_len, l->rdata.align, rdata_i.io);
 	rdata_i.offset = data_len;
 	l->rdata_offset += data_len;
 
@@ -125,7 +132,7 @@ static BOOL api_netsec_create_pdu(rpcsrv_struct *l, uint32 data_start,
 	/* happen to know that NETSEC authentication verifier is 32 bytes */
 	frag_len = data_len + auth_len + 8 + 0x18;
 
-	prs_init(&rauth , 8       , 4, False);
+	prs_init(&rauth, 8, 4, False);
 	prs_init(&rverf, auth_len, 4, False);
 
 	make_rpc_hdr_auth(&auth_info, 0x44, 0x06, 0x0, 1);
@@ -145,10 +152,10 @@ static BOOL api_netsec_create_pdu(rpcsrv_struct *l, uint32 data_start,
 
 	if (ret)
 	{
-		prs_link(NULL     , &rhdr      , &rdata_i  );
-		prs_link(&rhdr     , &rdata_i  , &rauth );
-		prs_link(&rdata_i , &rauth , &rverf);
-		prs_link(&rauth, &rverf, NULL      );
+		prs_link(NULL, &rhdr, &rdata_i);
+		prs_link(&rhdr, &rdata_i, &rauth);
+		prs_link(&rdata_i, &rauth, &rverf);
+		prs_link(&rauth, &rverf, NULL);
 
 		prs_init(resp, 0, 4, False);
 		ret = prs_copy(resp, &rhdr);
@@ -156,30 +163,29 @@ static BOOL api_netsec_create_pdu(rpcsrv_struct *l, uint32 data_start,
 
 	prs_free_data(&rauth);
 	prs_free_data(&rverf);
-	prs_free_data(&rhdr );
+	prs_free_data(&rhdr);
 
-	if (IS_BITS_SET_ALL(l->hdr.flags, RPC_FLG_LAST) ||
-	    l->hdr.pkt_type == RPC_BINDACK)
+	if (IS_BITS_SET_ALL(flags, RPC_FLG_LAST))
 	{
-		DEBUG(10,("create_netsec_reply: finished sending\n"));
+		DEBUG(10, ("create_netsec_reply: finished sending\n"));
 		prs_free_data(&l->rdata);
 	}
 
 	return ret;
 }
 
-static BOOL api_netsec_verify(rpcsrv_struct *l)
+static BOOL api_netsec_verify(rpcsrv_struct * l)
 {
-	netsec_auth_struct *a = (netsec_auth_struct *)l->auth_info;
+	netsec_auth_struct *a = (netsec_auth_struct *) l->auth_info;
 	struct dcinfo dc;
 
-	DEBUG(5,("api_netsec_verify: checking credential details\n"));
+	DEBUG(5, ("api_netsec_verify: checking credential details\n"));
 
 	/*
 	 * obtain the session key
 	 */
 	if (!cred_get(l->key.pid,
-	              a->netsec_neg.domain, a->netsec_neg.myname, &dc))
+		      a->netsec_neg.domain, a->netsec_neg.myname, &dc))
 	{
 		return False;
 	}
@@ -203,7 +209,7 @@ static BOOL api_netsec_verify(rpcsrv_struct *l)
 	return l->auth_validated;
 }
 
-static BOOL api_netsec(rpcsrv_struct *l, uint32 msg_type)
+static BOOL api_netsec(rpcsrv_struct * l, uint32 msg_type)
 {
 	switch (msg_type)
 	{
@@ -211,18 +217,20 @@ static BOOL api_netsec(rpcsrv_struct *l, uint32 msg_type)
 		case 0x13:
 		{
 			netsec_auth_struct *a;
-			a = (netsec_auth_struct *)l->auth_info;
+			a = (netsec_auth_struct *) l->auth_info;
 
-			smb_io_rpc_auth_netsec_neg("", &a->netsec_neg, &l->data_i, 0);
-			if (l->data_i.offset == 0) return False;
+			smb_io_rpc_auth_netsec_neg("", &a->netsec_neg,
+						   &l->data_i, 0);
+			if (l->data_i.offset == 0)
+				return False;
 
 			return api_netsec_verify(l);
 		}
 		default:
 		{
 			/* NEGSEC expected: unexpected message type */
-			DEBUG(3,("unexpected message type in NEGSEC %d\n",
-			          msg_type));
+			DEBUG(3, ("unexpected message type in NEGSEC %d\n",
+				  msg_type));
 			return False;
 		}
 	}
@@ -230,16 +238,17 @@ static BOOL api_netsec(rpcsrv_struct *l, uint32 msg_type)
 	return False;
 }
 
-static BOOL api_netsec_auth_chk(rpcsrv_struct *l,
-				enum RPC_PKT_TYPE pkt_type)
+static BOOL api_netsec_auth_chk(rpcsrv_struct * l, enum RPC_PKT_TYPE pkt_type)
 {
 	switch (pkt_type)
 	{
 		case RPC_BINDACK:
 		{
 			RPC_AUTH_VERIFIER auth_verifier;
-			smb_io_rpc_auth_verifier("", &auth_verifier, &l->data_i, 0);
-			if (l->data_i.offset == 0) return False;
+			smb_io_rpc_auth_verifier("", &auth_verifier,
+						 &l->data_i, 0);
+			if (l->data_i.offset == 0)
+				return False;
 
 			if (strequal(auth_verifier.signature, ""))
 			{
@@ -249,19 +258,20 @@ static BOOL api_netsec_auth_chk(rpcsrv_struct *l,
 		}
 		default:
 		{
-			DEBUG(10,("api_netsec_auth_chk: unknown pkt_type %x\n",
-			           pkt_type));
+			DEBUG(10,
+			      ("api_netsec_auth_chk: unknown pkt_type %x\n",
+			       pkt_type));
 			return False;
 		}
 	}
 	return False;
 }
 
-static BOOL api_netsec_auth_gen(rpcsrv_struct *l, prs_struct *resp,
+static BOOL api_netsec_auth_gen(rpcsrv_struct * l, prs_struct * resp,
 				enum RPC_PKT_TYPE pkt_type)
 {
 	BOOL ret;
-	RPC_HDR_AUTH  auth_info;
+	RPC_HDR_AUTH auth_info;
 	RPC_AUTH_VERIFIER auth_verifier;
 	RPC_AUTH_NETSEC_RESP auth_resp;
 	prs_struct rhdr;
@@ -269,7 +279,7 @@ static BOOL api_netsec_auth_gen(rpcsrv_struct *l, prs_struct *resp,
 	prs_struct rverf;
 	prs_struct rresp;
 
-	prs_init(&(rhdr ), 0, 4, False);
+	prs_init(&(rhdr), 0, 4, False);
 	prs_init(&(rauth), 0, 4, False);
 	prs_init(&(rverf), 0, 4, False);
 	prs_init(&(rresp), 0, 4, False);
@@ -286,7 +296,7 @@ static BOOL api_netsec_auth_gen(rpcsrv_struct *l, prs_struct *resp,
 	smb_io_rpc_auth_verifier("", &auth_verifier, &rauth, 0);
 	prs_realloc_data(&rauth, rauth.offset);
 
-	/* NETSEC challenge ***/
+	/* NETSEC challenge ** */
 
 	make_rpc_auth_netsec_resp(&auth_resp, 0x05);
 	smb_io_rpc_auth_netsec_resp("", &auth_resp, &rresp, 0);
@@ -298,8 +308,8 @@ static BOOL api_netsec_auth_gen(rpcsrv_struct *l, prs_struct *resp,
 
 	make_rpc_hdr(&l->hdr, pkt_type, RPC_FLG_FIRST | RPC_FLG_LAST,
 		     l->hdr.call_id,
-		     l->rdata.offset + rverf.offset + rauth.offset + rresp.offset + 0x10,
-		     rauth.offset + rresp.offset);
+		     l->rdata.offset + rverf.offset + rauth.offset +
+		     rresp.offset + 0x10, rauth.offset + rresp.offset);
 
 	smb_io_rpc_hdr("", &l->hdr, &rhdr, 0);
 	prs_realloc_data(&rhdr, l->rdata.offset);
@@ -308,27 +318,27 @@ static BOOL api_netsec_auth_gen(rpcsrv_struct *l, prs_struct *resp,
 	/*** link rpc header, bind ack and auth responses ***/
 	/***/
 
-	prs_link(NULL     , &rhdr    , &l->rdata);
-	prs_link(&rhdr    , &l->rdata, &rverf   );
-	prs_link(&l->rdata, &rverf   , &rauth   );
-	prs_link(&rverf   , &rauth   , &rresp   );
-	prs_link(&rauth   , &rresp   , NULL     );
+	prs_link(NULL, &rhdr, &l->rdata);
+	prs_link(&rhdr, &l->rdata, &rverf);
+	prs_link(&l->rdata, &rverf, &rauth);
+	prs_link(&rverf, &rauth, &rresp);
+	prs_link(&rauth, &rresp, NULL);
 
 	prs_init(resp, 0, 4, False);
 	ret = prs_copy(resp, &rhdr);
 
 	prs_free_data(&l->rdata);
-	prs_free_data(&rhdr    );
-	prs_free_data(&rauth   );
-	prs_free_data(&rverf   );
-	prs_free_data(&rresp   );		
+	prs_free_data(&rhdr);
+	prs_free_data(&rauth);
+	prs_free_data(&rverf);
+	prs_free_data(&rresp);
 
 	return ret;
 }
 
-static BOOL api_netsec_decode_pdu(rpcsrv_struct *l)
+static BOOL api_netsec_decode_pdu(rpcsrv_struct * l)
 {
-	netsec_auth_struct *a = (netsec_auth_struct *)l->auth_info;
+	netsec_auth_struct *a = (netsec_auth_struct *) l->auth_info;
 	int data_len;
 	int auth_len;
 	uint32 old_offset;
@@ -337,28 +347,28 @@ static BOOL api_netsec_decode_pdu(rpcsrv_struct *l)
 
 	auth_len = l->hdr.auth_len;
 
-	if (auth_len != 0x20 )
+	if (auth_len != 0x20)
 	{
 		return False;
 	}
 
 	data_len = l->hdr.frag_len - auth_len - 8 - 0x18;
-	
-	DEBUG(5,("api_pipe_auth_process: data %d auth %d\n",
-	         data_len, auth_len));
+
+	DEBUG(5, ("api_pipe_auth_process: data %d auth %d\n",
+		  data_len, auth_len));
 
 	/*** skip the data, record the offset so we can restore it again */
 	old_offset = l->data_i.offset;
 
 	l->data_i.offset += data_len;
 	smb_io_rpc_hdr_auth("hdr_auth", &auth_info, &l->data_i, 0);
-	if (!rpc_hdr_netsec_auth_chk(&(auth_info))) return False;
+	if (!rpc_hdr_netsec_auth_chk(&(auth_info)))
+		return False;
 
 	smb_io_rpc_auth_netsec_chk("auth_sign", &netsec_chk, &l->data_i, 0);
 
 	if (!netsec_decode(a, &netsec_chk,
-	                   prs_data(&l->data_i, old_offset),
-	                   data_len))
+			   prs_data(&l->data_i, old_offset), data_len))
 	{
 		return False;
 	}
@@ -369,23 +379,21 @@ static BOOL api_netsec_decode_pdu(rpcsrv_struct *l)
 	return True;
 }
 
-static BOOL api_netsec_hdr_chk(RPC_HDR_AUTH *auth_info, void **auth_struct)
+static BOOL api_netsec_hdr_chk(RPC_HDR_AUTH * auth_info, void **auth_struct)
 {
-	DEBUG(10,("api_netsec_hdr_chk:\n"));
+	DEBUG(10, ("api_netsec_hdr_chk:\n"));
 	if (!rpc_hdr_netsec_auth_chk(auth_info))
 	{
 		return False;
 	}
-	(*auth_struct) = (void*)malloc(sizeof(netsec_auth_struct));
+	(*auth_struct) = (void *)malloc(sizeof(netsec_auth_struct));
 	return (*auth_struct) != NULL;
 }
 
-srv_auth_fns netsec_fns = 
-{
+srv_auth_fns netsec_fns = {
 	api_netsec_hdr_chk,
 	api_netsec_auth_chk,
 	api_netsec_auth_gen,
 	api_netsec_decode_pdu,
 	api_netsec_create_pdu,
 };
-
diff --git a/source/rpc_server/srv_pipe_noauth.c b/source/rpc_server/srv_pipe_noauth.c
index d486ffb452f..e998a0874ad 100644
--- a/source/rpc_server/srv_pipe_noauth.c
+++ b/source/rpc_server/srv_pipe_noauth.c
@@ -3,9 +3,9 @@
  *  Unix SMB/Netbios implementation.
  *  Version 1.9.
  *  RPC Pipe client / server routines
- *  Copyright (C) Andrew Tridgell              1992-1998
- *  Copyright (C) Luke Kenneth Casson Leighton 1996-1998,
- *  Copyright (C) Paul Ashton                  1997-1998.
+ *  Copyright (C) Andrew Tridgell              1992-2000,
+ *  Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
+ *  Copyright (C) Paul Ashton                  1997-2000.
  *  
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -33,104 +33,107 @@ extern int DEBUGLEVEL;
 /*******************************************************************
 turns a DCE/RPC request into a DCE/RPC reply
 ********************************************************************/
-static BOOL api_noauth_create_pdu(rpcsrv_struct *l, uint32 data_start,
-				prs_struct *resp)
+static BOOL api_noauth_create_pdu(rpcsrv_struct * l, uint32 data_start,
+				  prs_struct * resp)
 {
 	BOOL ret;
 	uint32 data_len;
-	uint32 auth_len;
+	uint32 frag_len;
 	uint32 data_end = l->rdata.offset;
 	prs_struct rhdr;
 	prs_struct rdata_i;
-	RPC_HDR_RESP  hdr_resp;
+	RPC_HDR_RESP hdr_resp;
+	uint8 flags = 0x0;
+	uint32 call_id = l->hdr.call_id;
 
-	DEBUG(5,("create_noauth_reply: data_start: %d data_end: %d max_tsize: %d\n",
-	          data_start, data_end, l->hdr_ba.bba.max_tsize));
+	DEBUG(5,
+	      ("create_noauth_reply: data_start: %d data_end: %d max_tsize: %d\n",
+	       data_start, data_end, l->hdr_ba.bba.max_tsize));
 
-	auth_len = l->hdr.auth_len;
-
-	if (auth_len != 0)
+	if (l->hdr.auth_len != 0)
 	{
 		return False;
 	}
 
-	prs_init(&rhdr , 0, 4, False);
-
-	l->hdr.pkt_type = RPC_RESPONSE; /* mark header as an rpc response */
+	prs_init(&rhdr, 0, 4, False);
 
 	/* set up rpc header (fragmentation issues) */
 	if (data_start == 0)
 	{
-		l->hdr.flags = RPC_FLG_FIRST;
+		flags = RPC_FLG_FIRST;
 	}
 	else
 	{
-		l->hdr.flags = 0;
+		flags = 0;
 	}
 
-	hdr_resp.alloc_hint = data_end - data_start; /* calculate remaining data to be sent */
+	hdr_resp.alloc_hint = data_end - data_start;	/* calculate remaining data to be sent */
 	hdr_resp.cancel_count = 0x0;
-	hdr_resp.context_id   = 0x0;
-	hdr_resp.reserved     = 0x0;
+	hdr_resp.context_id = 0x0;
+	hdr_resp.reserved = 0x0;
 
-	DEBUG(10,("alloc_hint: %d\n", hdr_resp.alloc_hint));
+	DEBUG(10, ("alloc_hint: %d\n", hdr_resp.alloc_hint));
 
 	if (hdr_resp.alloc_hint + 0x18 <= l->hdr_ba.bba.max_tsize)
 	{
-		l->hdr.flags |= RPC_FLG_LAST;
-		l->hdr.frag_len = hdr_resp.alloc_hint + 0x18;
+		flags |= RPC_FLG_LAST;
+		frag_len = hdr_resp.alloc_hint + 0x18;
 	}
 	else
 	{
-		l->hdr.frag_len = l->hdr_ba.bba.max_tsize;
+		frag_len = l->hdr_ba.bba.max_tsize;
 	}
 
-	data_len = l->hdr.frag_len - 0x18;
+	data_len = frag_len - 0x18;
 
 	rhdr.start = 0;
-	rhdr.end   = 0x18;
+	rhdr.end = 0x18;
 
-	DEBUG(10,("hdr flags: %x\n", l->hdr.flags));
+	if (!make_rpc_hdr(&l->hdr, RPC_RESPONSE, flags, call_id, frag_len, 0))
+	{
+		return False;
+	}
+
+	DEBUG(10, ("hdr flags: %x\n", flags));
 
 	/* store the header in the data stream */
-	smb_io_rpc_hdr     ("rhdr", &(l->hdr     ), &(rhdr), 0);
+	smb_io_rpc_hdr("rhdr", &(l->hdr), &(rhdr), 0);
 	smb_io_rpc_hdr_resp("resp", &(hdr_resp), &(rhdr), 0);
 
 	/* don't use rdata: use rdata_i instead, which moves... */
 	/* make a pointer to the rdata data, NOT A COPY */
 
 	prs_create(&rdata_i, prs_data(&l->rdata, data_start),
-	                     data_len, l->rdata.align, rdata_i.io); 
+		   data_len, l->rdata.align, rdata_i.io);
 	rdata_i.offset = data_len;
 	l->rdata_offset += data_len;
 
 	prs_debug_out(&rdata_i, "rdata_i", 200);
 	prs_debug_out(&l->rdata, "rdata", 200);
 
-	prs_link(NULL , &rhdr   , &rdata_i);
-	prs_link(&rhdr, &rdata_i, NULL    );
+	prs_link(NULL, &rhdr, &rdata_i);
+	prs_link(&rhdr, &rdata_i, NULL);
 
 	prs_init(resp, 0, 4, False);
 	ret = prs_copy(resp, &rhdr);
 
-	prs_free_data(&rhdr );
+	prs_free_data(&rhdr);
 
 	return ret;
 }
 
-static BOOL api_noauth_auth_gen(rpcsrv_struct *l, prs_struct *resp,
+static BOOL api_noauth_auth_gen(rpcsrv_struct * l, prs_struct * resp,
 				enum RPC_PKT_TYPE pkt_type)
 {
 	prs_struct rhdr;
 	BOOL ret;
 
-	DEBUG(10,("api_noauth_auth_gen\n"));
+	DEBUG(10, ("api_noauth_auth_gen\n"));
 
 	prs_init(&rhdr, 0, 4, False);
 
 	make_rpc_hdr(&l->hdr, pkt_type, RPC_FLG_FIRST | RPC_FLG_LAST,
-		     l->hdr.call_id,
-		     l->rdata.offset + 0x10, 0);
+		     l->hdr.call_id, l->rdata.offset + 0x10, 0);
 
 	smb_io_rpc_hdr("", &l->hdr, &rhdr, 0);
 	prs_realloc_data(&rhdr, l->rdata.offset);
@@ -139,36 +142,34 @@ static BOOL api_noauth_auth_gen(rpcsrv_struct *l, prs_struct *resp,
 	/*** link rpc header and bind acknowledgment ***/
 	/***/
 
-	prs_link(NULL    , &rhdr , &l->rdata);
-	prs_link(&rhdr, &l->rdata, NULL     );
+	prs_link(NULL, &rhdr, &l->rdata);
+	prs_link(&rhdr, &l->rdata, NULL);
 
 	prs_init(resp, 0, 4, False);
 	ret = prs_copy(resp, &rhdr);
 
 	prs_free_data(&l->rdata);
-	prs_free_data(&rhdr );
+	prs_free_data(&rhdr);
 
 	return ret;
 }
 
-static BOOL api_noauth_auth_chk(rpcsrv_struct *l, enum RPC_PKT_TYPE pkt_type)
+static BOOL api_noauth_auth_chk(rpcsrv_struct * l, enum RPC_PKT_TYPE pkt_type)
 {
 	l->auth_validated = True;
 
 	return True;
 }
 
-static BOOL api_noauth_decode_pdu(rpcsrv_struct *l)
+static BOOL api_noauth_decode_pdu(rpcsrv_struct * l)
 {
 	return True;
 }
 
-srv_auth_fns noauth_fns = 
-{
+srv_auth_fns noauth_fns = {
 	NULL,
 	api_noauth_auth_chk,
 	api_noauth_auth_gen,
 	api_noauth_decode_pdu,
 	api_noauth_create_pdu,
 };
-
diff --git a/source/rpc_server/srv_pipe_ntlmssp.c b/source/rpc_server/srv_pipe_ntlmssp.c
index 19fa70aef73..a93c1d174c1 100644
--- a/source/rpc_server/srv_pipe_ntlmssp.c
+++ b/source/rpc_server/srv_pipe_ntlmssp.c
@@ -67,13 +67,16 @@ static BOOL api_ntlmssp_create_pdu(rpcsrv_struct * l, uint32 data_start,
 
 	BOOL ret;
 	BOOL auth_verify = IS_BITS_SET_ALL(a->ntlmssp_chal.neg_flags,
-				NTLMSSP_NEGOTIATE_SIGN);
+					   NTLMSSP_NEGOTIATE_SIGN);
 	BOOL auth_seal = IS_BITS_SET_ALL(a->ntlmssp_chal.neg_flags,
-				NTLMSSP_NEGOTIATE_SEAL);
+					 NTLMSSP_NEGOTIATE_SEAL);
 	uint32 data_len;
 	uint32 auth_len;
+	uint32 frag_len;
 	uint32 data_end = l->rdata.offset + (l->auth ? (8 + 16) : 0);
 	uint32 crc32 = 0;
+	uint8 flags;
+	uint32 call_id = l->hdr.call_id;
 	char *data;
 
 	prs_struct rhdr;
@@ -98,16 +101,14 @@ static BOOL api_ntlmssp_create_pdu(rpcsrv_struct * l, uint32 data_start,
 
 	prs_init(&rhdr, 0, 4, False);
 
-	l->hdr.pkt_type = RPC_RESPONSE;	/* mark header as an rpc response */
-
 	/* set up rpc header (fragmentation issues) */
 	if (data_start == 0)
 	{
-		l->hdr.flags = RPC_FLG_FIRST;
+		flags = RPC_FLG_FIRST;
 	}
 	else
 	{
-		l->hdr.flags = 0;
+		flags = 0;
 	}
 
 	hdr_resp.alloc_hint = data_end - data_start;	/* calculate remaining data to be sent */
@@ -119,22 +120,28 @@ static BOOL api_ntlmssp_create_pdu(rpcsrv_struct * l, uint32 data_start,
 
 	if (hdr_resp.alloc_hint + 0x18 <= l->hdr_ba.bba.max_tsize)
 	{
-		l->hdr.flags |= RPC_FLG_LAST;
-		l->hdr.frag_len = hdr_resp.alloc_hint + 0x18;
+		flags |= RPC_FLG_LAST;
+		frag_len = hdr_resp.alloc_hint + 0x18;
 	}
 	else
 	{
-		l->hdr.frag_len = l->hdr_ba.bba.max_tsize;
+		frag_len = l->hdr_ba.bba.max_tsize;
 	}
 
 	hdr_resp.alloc_hint -= auth_len + 8;
 
-	data_len = l->hdr.frag_len - auth_len - (auth_verify ? 8 : 0) - 0x18;
+	data_len = frag_len - auth_len - (auth_verify ? 8 : 0) - 0x18;
 
 	rhdr.start = 0;
 	rhdr.end = 0x18;
 
-	DEBUG(10, ("hdr flags: %x\n", l->hdr.flags));
+	DEBUG(10, ("hdr flags: %x\n", flags));
+
+	if (!make_rpc_hdr(&l->hdr, RPC_RESPONSE, flags, call_id,
+			  frag_len, auth_len))
+	{
+		return False;
+	}
 
 	/* store the header in the data stream */
 	smb_io_rpc_hdr("rhdr", &(l->hdr), &(rhdr), 0);
@@ -195,8 +202,7 @@ static BOOL api_ntlmssp_create_pdu(rpcsrv_struct * l, uint32 data_start,
 	prs_free_data(&rverf);
 	prs_free_data(&rhdr);
 
-	if (IS_BITS_SET_ALL(l->hdr.flags, RPC_FLG_LAST) ||
-	    l->hdr.pkt_type == RPC_BINDACK)
+	if (IS_BITS_SET_ALL(flags, RPC_FLG_LAST))
 	{
 		DEBUG(10, ("create_ntlmssp_reply: finished sending\n"));
 		prs_free_data(&l->rdata);
@@ -474,7 +480,7 @@ static BOOL api_ntlmssp_auth_chk(rpcsrv_struct * l,
 		{
 			RPC_AUTH_VERIFIER auth_verifier;
 			if (!smb_io_rpc_auth_verifier("", &auth_verifier,
-						 &l->data_i, 0))
+						      &l->data_i, 0))
 			{
 				return False;
 			}
@@ -572,9 +578,9 @@ static BOOL api_ntlmssp_decode_pdu(rpcsrv_struct * l)
 {
 	ntlmssp_auth_struct *a = (ntlmssp_auth_struct *) l->auth_info;
 	BOOL auth_verify = IS_BITS_SET_ALL(a->ntlmssp_chal.neg_flags,
-				NTLMSSP_NEGOTIATE_SIGN);
+					   NTLMSSP_NEGOTIATE_SIGN);
 	BOOL auth_seal = IS_BITS_SET_ALL(a->ntlmssp_chal.neg_flags,
-				NTLMSSP_NEGOTIATE_SEAL);
+					 NTLMSSP_NEGOTIATE_SEAL);
 	int data_len;
 	int auth_len;
 	uint32 old_offset;