From d6b3fce078869de35334c0805ff141dc8bcf5f65 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Thu, 18 Jan 2007 10:18:59 +0000
Subject: r20875: Pass DCE/RPC server call arguments as a struct rather than as
 separate arguments.

This makes it a bit more similar to the Samba4 code.
(This used to be commit 0596badb410a58e7a715e2b17bc0bef0489a2448)
---
 source3/rpc_server/srv_dfs_nt.c          | 112 ++++----
 source3/rpc_server/srv_echo_nt.c         |  66 ++---
 source3/rpc_server/srv_initshutdown_nt.c |  33 ++-
 source3/rpc_server/srv_lsa_nt.c          | 180 ++++++------
 source3/rpc_server/srv_srvsvc_nt.c       | 460 +++++++++++++++----------------
 source3/rpc_server/srv_unixinfo_nt.c     |  49 ++--
 source3/rpc_server/srv_winreg_nt.c       | 324 ++++++++++------------
 source3/rpc_server/srv_wkssvc_nt.c       |  74 +++--
 8 files changed, 629 insertions(+), 669 deletions(-)

(limited to 'source3/rpc_server')

diff --git a/source3/rpc_server/srv_dfs_nt.c b/source3/rpc_server/srv_dfs_nt.c
index 4857a839e1..98818826df 100644
--- a/source3/rpc_server/srv_dfs_nt.c
+++ b/source3/rpc_server/srv_dfs_nt.c
@@ -30,15 +30,15 @@
 /* This function does not return a WERROR or NTSTATUS code but rather 1 if
    dfs exists, or 0 otherwise. */
 
-void _dfs_GetManagerVersion(pipes_struct *p, uint32 *exists)
+void _dfs_GetManagerVersion(pipes_struct *p, struct dfs_GetManagerVersion *r)
 {
 	if(lp_host_msdfs()) 
-		*exists = 1;
+		*r->out.exist_flag = 1;
 	else
-		*exists = 0;
+		*r->out.exist_flag = 0;
 }
 
-WERROR _dfs_Add(pipes_struct *p, const char *path, const char *server, const char *share, const char *comment, uint32_t flags)
+WERROR _dfs_Add(pipes_struct *p, struct dfs_Add *r)
 {
 	struct junction_map jn;
 	struct referral* old_referral_list = NULL;
@@ -52,14 +52,14 @@ WERROR _dfs_Add(pipes_struct *p, const char *path, const char *server, const cha
 	}
 
 	DEBUG(5,("init_reply_dfs_add: Request to add %s -> %s\\%s.\n",
-		path, server, share));
+		r->in.path, r->in.server, r->in.share));
 
-	pstrcpy(altpath, server);
+	pstrcpy(altpath, r->in.server);
 	pstrcat(altpath, "\\");
-	pstrcat(altpath, share);
+	pstrcat(altpath, r->in.share);
 
 	/* The following call can change the cwd. */
-	if(get_referred_path(p->mem_ctx, path, &jn, NULL, NULL)) {
+	if(get_referred_path(p->mem_ctx, r->in.path, &jn, NULL, NULL)) {
 		exists = True;
 		jn.referral_count += 1;
 		old_referral_list = jn.referral_list;
@@ -93,7 +93,7 @@ WERROR _dfs_Add(pipes_struct *p, const char *path, const char *server, const cha
 	return WERR_OK;
 }
 
-WERROR _dfs_Remove(pipes_struct *p, const char *path, const char *server, const char *share)
+WERROR _dfs_Remove(pipes_struct *p, struct dfs_Remove *r)
 {
 	struct junction_map jn;
 	BOOL found = False;
@@ -105,22 +105,22 @@ WERROR _dfs_Remove(pipes_struct *p, const char *path, const char *server, const
 		return WERR_ACCESS_DENIED;
 	}
 
-	if(server && share) {
-		pstrcpy(altpath, server);
+	if (r->in.server && r->in.share) {
+		pstrcpy(altpath, r->in.server);
 		pstrcat(altpath, "\\");
-		pstrcat(altpath, share);
+		pstrcat(altpath, r->in.share);
 		strlower_m(altpath);
 	}
 
 	DEBUG(5,("init_reply_dfs_remove: Request to remove %s -> %s\\%s.\n",
-		path, server, share));
+		r->in.path, r->in.server, r->in.share));
 
-	if(!get_referred_path(p->mem_ctx, path, &jn, NULL, NULL)) {
+	if(!get_referred_path(p->mem_ctx, r->in.path, &jn, NULL, NULL)) {
 		return WERR_DFS_NO_SUCH_VOL;
 	}
 
 	/* if no server-share pair given, remove the msdfs link completely */
-	if(!server && !share) {
+	if(!r->in.server && !r->in.share) {
 		if(!remove_msdfs_link(&jn)) {
 			vfs_ChDir(p->conn,p->conn->connectpath);
 			return WERR_DFS_NO_SUCH_VOL;
@@ -242,7 +242,7 @@ static BOOL init_reply_dfs_info_100(TALLOC_CTX *mem_ctx, struct junction_map* j,
 }
 
 
-WERROR _dfs_Enum(pipes_struct *p, uint32_t level, uint32_t bufsize, struct dfs_EnumStruct *info, uint32_t *unknown, uint32_t *total)
+WERROR _dfs_Enum(pipes_struct *p, struct dfs_Enum *r)
 {
 	struct junction_map jn[MAX_MSDFS_JUNCTIONS];
 	int num_jn = 0;
@@ -251,44 +251,44 @@ WERROR _dfs_Enum(pipes_struct *p, uint32_t level, uint32_t bufsize, struct dfs_E
 	num_jn = enum_msdfs_links(p->mem_ctx, jn, ARRAY_SIZE(jn));
 	vfs_ChDir(p->conn,p->conn->connectpath);
     
-	DEBUG(5,("_dfs_Enum: %d junctions found in Dfs, doing level %d\n", num_jn, level));
+	DEBUG(5,("_dfs_Enum: %d junctions found in Dfs, doing level %d\n", num_jn, r->in.level));
 
-	*total = num_jn;
+	*r->out.total = num_jn;
 
 	/* Create the return array */
-	switch (level) {
+	switch (r->in.level) {
 	case 1:
-		if ((info->e.info1->s = TALLOC_ARRAY(p->mem_ctx, struct dfs_Info1, num_jn)) == NULL) {
+		if ((r->out.info->e.info1->s = TALLOC_ARRAY(p->mem_ctx, struct dfs_Info1, num_jn)) == NULL) {
 			return WERR_NOMEM;
 		}
-		info->e.info1->count = num_jn;
+		r->out.info->e.info1->count = num_jn;
 		break;
 	case 2:
-		if ((info->e.info2->s = TALLOC_ARRAY(p->mem_ctx, struct dfs_Info2, num_jn)) == NULL) {
+		if ((r->out.info->e.info2->s = TALLOC_ARRAY(p->mem_ctx, struct dfs_Info2, num_jn)) == NULL) {
 			return WERR_NOMEM;
 		}
-		info->e.info2->count = num_jn;
+		r->out.info->e.info2->count = num_jn;
 		break;
 	case 3:
-		if ((info->e.info3->s = TALLOC_ARRAY(p->mem_ctx, struct dfs_Info3, num_jn)) == NULL) {
+		if ((r->out.info->e.info3->s = TALLOC_ARRAY(p->mem_ctx, struct dfs_Info3, num_jn)) == NULL) {
 			return WERR_NOMEM;
 		}
-		info->e.info3->count = num_jn;
+		r->out.info->e.info3->count = num_jn;
 		break;
 	default:
 		return WERR_INVALID_PARAM;
 	}
 
 	for (i = 0; i < num_jn; i++) {
-		switch (level) {
+		switch (r->in.level) {
 		case 1: 
-			init_reply_dfs_info_1(p->mem_ctx, &jn[i], &info->e.info1->s[i]);
+			init_reply_dfs_info_1(p->mem_ctx, &jn[i], &r->out.info->e.info1->s[i]);
 			break;
 		case 2:
-			init_reply_dfs_info_2(p->mem_ctx, &jn[i], &info->e.info2->s[i]);
+			init_reply_dfs_info_2(p->mem_ctx, &jn[i], &r->out.info->e.info2->s[i]);
 			break;
 		case 3:
-			init_reply_dfs_info_3(p->mem_ctx, &jn[i], &info->e.info3->s[i]);
+			init_reply_dfs_info_3(p->mem_ctx, &jn[i], &r->out.info->e.info3->s[i]);
 			break;
 		default:
 			return WERR_INVALID_PARAM;
@@ -298,30 +298,30 @@ WERROR _dfs_Enum(pipes_struct *p, uint32_t level, uint32_t bufsize, struct dfs_E
 	return WERR_OK;
 }
       
-WERROR _dfs_GetInfo(pipes_struct *p, const char *path, const char *server, const char *share, uint32_t level, union dfs_Info *info)
+WERROR _dfs_GetInfo(pipes_struct *p, struct dfs_GetInfo *r)
 {
 	int consumedcnt = sizeof(pstring);
 	struct junction_map jn;
 	BOOL ret;
 
-	if(!create_junction(path, &jn))
+	if(!create_junction(r->in.path, &jn))
 		return WERR_DFS_NO_SUCH_SERVER;
   
 	/* The following call can change the cwd. */
-	if(!get_referred_path(p->mem_ctx, path, &jn, &consumedcnt, NULL) || consumedcnt < strlen(path)) {
+	if(!get_referred_path(p->mem_ctx, r->in.path, &jn, &consumedcnt, NULL) || consumedcnt < strlen(r->in.path)) {
 		vfs_ChDir(p->conn,p->conn->connectpath);
 		return WERR_DFS_NO_SUCH_VOL;
 	}
 
 	vfs_ChDir(p->conn,p->conn->connectpath);
 
-	switch (level) {
-		case 1: ret = init_reply_dfs_info_1(p->mem_ctx, &jn, info->info1); break;
-		case 2: ret = init_reply_dfs_info_2(p->mem_ctx, &jn, info->info2); break;
-		case 3: ret = init_reply_dfs_info_3(p->mem_ctx, &jn, info->info3); break;
-		case 100: ret = init_reply_dfs_info_100(p->mem_ctx, &jn, info->info100); break;
+	switch (r->in.level) {
+		case 1: ret = init_reply_dfs_info_1(p->mem_ctx, &jn, r->out.info->info1); break;
+		case 2: ret = init_reply_dfs_info_2(p->mem_ctx, &jn, r->out.info->info2); break;
+		case 3: ret = init_reply_dfs_info_3(p->mem_ctx, &jn, r->out.info->info3); break;
+		case 100: ret = init_reply_dfs_info_100(p->mem_ctx, &jn, r->out.info->info100); break;
 		default:
-			info->info1 = NULL;
+			r->out.info->info1 = NULL;
 			return WERR_INVALID_PARAM;
 	}
 
@@ -331,126 +331,126 @@ WERROR _dfs_GetInfo(pipes_struct *p, const char *path, const char *server, const
 	return WERR_OK;
 }
 
-WERROR _dfs_SetInfo(pipes_struct *p)
+WERROR _dfs_SetInfo(pipes_struct *p, struct dfs_SetInfo *r)
 {
 	/* FIXME: Implement your code here */
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _dfs_Rename(pipes_struct *p)
+WERROR _dfs_Rename(pipes_struct *p, struct dfs_Rename *r)
 {
 	/* FIXME: Implement your code here */
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _dfs_Move(pipes_struct *p)
+WERROR _dfs_Move(pipes_struct *p, struct dfs_Move *r)
 {
 	/* FIXME: Implement your code here */
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _dfs_ManagerGetConfigInfo(pipes_struct *p)
+WERROR _dfs_ManagerGetConfigInfo(pipes_struct *p, struct dfs_ManagerGetConfigInfo *r)
 {
 	/* FIXME: Implement your code here */
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _dfs_ManagerSendSiteInfo(pipes_struct *p)
+WERROR _dfs_ManagerSendSiteInfo(pipes_struct *p, struct dfs_ManagerSendSiteInfo *r)
 {
 	/* FIXME: Implement your code here */
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _dfs_AddFtRoot(pipes_struct *p)
+WERROR _dfs_AddFtRoot(pipes_struct *p, struct dfs_AddFtRoot *r)
 {
 	/* FIXME: Implement your code here */
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _dfs_RemoveFtRoot(pipes_struct *p)
+WERROR _dfs_RemoveFtRoot(pipes_struct *p, struct dfs_RemoveFtRoot *r)
 {
 	/* FIXME: Implement your code here */
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _dfs_AddStdRoot(pipes_struct *p)
+WERROR _dfs_AddStdRoot(pipes_struct *p, struct dfs_AddStdRoot *r)
 {
 	/* FIXME: Implement your code here */
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _dfs_RemoveStdRoot(pipes_struct *p)
+WERROR _dfs_RemoveStdRoot(pipes_struct *p, struct dfs_RemoveStdRoot *r)
 {
 	/* FIXME: Implement your code here */
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _dfs_ManagerInitialize(pipes_struct *p)
+WERROR _dfs_ManagerInitialize(pipes_struct *p, struct dfs_ManagerInitialize *r)
 {
 	/* FIXME: Implement your code here */
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _dfs_AddStdRootForced(pipes_struct *p)
+WERROR _dfs_AddStdRootForced(pipes_struct *p, struct dfs_AddStdRootForced *r)
 {
 	/* FIXME: Implement your code here */
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _dfs_GetDcAddress(pipes_struct *p)
+WERROR _dfs_GetDcAddress(pipes_struct *p, struct dfs_GetDcAddress *r)
 {
 	/* FIXME: Implement your code here */
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _dfs_SetDcAddress(pipes_struct *p)
+WERROR _dfs_SetDcAddress(pipes_struct *p, struct dfs_SetDcAddress *r)
 {
 	/* FIXME: Implement your code here */
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _dfs_FlushFtTable(pipes_struct *p)
+WERROR _dfs_FlushFtTable(pipes_struct *p, struct dfs_FlushFtTable *r)
 {
 	/* FIXME: Implement your code here */
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _dfs_Add2(pipes_struct *p)
+WERROR _dfs_Add2(pipes_struct *p, struct dfs_Add2 *r)
 {
 	/* FIXME: Implement your code here */
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _dfs_Remove2(pipes_struct *p)
+WERROR _dfs_Remove2(pipes_struct *p, struct dfs_Remove2 *r)
 {
 	/* FIXME: Implement your code here */
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _dfs_EnumEx(pipes_struct *p, const char *name, uint32_t level, uint32_t bufsize, struct dfs_EnumStruct *info, uint32_t *total)
+WERROR _dfs_EnumEx(pipes_struct *p, struct dfs_EnumEx *r)
 {
 	/* FIXME: Implement your code here */
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _dfs_SetInfo2(pipes_struct *p)
+WERROR _dfs_SetInfo2(pipes_struct *p, struct dfs_SetInfo2 *r)
 {
 	/* FIXME: Implement your code here */
 	p->rng_fault_state = True;
diff --git a/source3/rpc_server/srv_echo_nt.c b/source3/rpc_server/srv_echo_nt.c
index b6c5442e03..eb095f6bfe 100644
--- a/source3/rpc_server/srv_echo_nt.c
+++ b/source3/rpc_server/srv_echo_nt.c
@@ -31,25 +31,25 @@
 
 /* Add one to the input and return it */
 
-void _echo_AddOne(pipes_struct *p, uint32_t in_data, uint32_t *out_data)
+void _echo_AddOne(pipes_struct *p, struct echo_AddOne *r)
 {
 	DEBUG(10, ("_echo_add_one\n"));
 
-	*out_data = in_data + 1;
+	*r->out.out_data = r->in.in_data + 1;
 }
 
 /* Echo back an array of data */
 
-void _echo_EchoData(pipes_struct *p, uint32_t len, uint8_t *in_data, uint8_t *out_data)
+void _echo_EchoData(pipes_struct *p, struct echo_EchoData *r)
 {
 	DEBUG(10, ("_echo_data\n"));
 
-	memcpy(out_data, in_data, len);
+	memcpy(r->out.out_data, r->in.in_data, r->in.len);
 }
 
 /* Sink an array of data */
 
-void _echo_SinkData(pipes_struct *p, uint32_t len, uint8_t *data)
+void _echo_SinkData(pipes_struct *p, struct echo_SinkData *r)
 {
 	DEBUG(10, ("_sink_data\n"));
 
@@ -58,47 +58,47 @@ void _echo_SinkData(pipes_struct *p, uint32_t len, uint8_t *data)
 
 /* Source an array of data */
 
-void _echo_SourceData(pipes_struct *p, uint32_t len, uint8_t *data)
+void _echo_SourceData(pipes_struct *p, struct echo_SourceData *r)
 {
 	uint32 i;
 
 	DEBUG(10, ("_source_data\n"));
 
-	for (i = 0; i < len; i++)
-		data[i] = i & 0xff;
+	for (i = 0; i < r->in.len; i++)
+		r->out.data[i] = i & 0xff;
 }
 
-void _echo_TestCall(pipes_struct *p, const char *s1, const char **s2)
+void _echo_TestCall(pipes_struct *p, struct echo_TestCall *r)
 {
-	*s2 = talloc_strdup(p->mem_ctx, s1);
+	*r->out.s2 = talloc_strdup(p->mem_ctx, r->in.s1);
 }
 
-NTSTATUS _echo_TestCall2(pipes_struct *p, uint16_t level, union echo_Info *info)
+NTSTATUS _echo_TestCall2(pipes_struct *p, struct echo_TestCall2 *r)
 {
-	switch (level) {
+	switch (r->in.level) {
 	case 1:
-		info->info1.v = 10;
+		r->out.info->info1.v = 10;
 		break;
 	case 2:
-		info->info2.v = 20;
+		r->out.info->info2.v = 20;
 		break;
 	case 3:
-		info->info3.v = 30;
+		r->out.info->info3.v = 30;
 		break;
 	case 4:
-		info->info4.v = 40;
+		r->out.info->info4.v = 40;
 		break;
 	case 5:
-		info->info5.v1 = 50;
-		info->info5.v2 = 60;
+		r->out.info->info5.v1 = 50;
+		r->out.info->info5.v2 = 60;
 		break;
 	case 6:
-		info->info6.v1 = 70;
-		info->info6.info1.v= 80;
+		r->out.info->info6.v1 = 70;
+		r->out.info->info6.info1.v= 80;
 		break;
 	case 7:
-		info->info7.v1 = 80;
-		info->info7.info4.v = 90;
+		r->out.info->info7.v1 = 80;
+		r->out.info->info7.info4.v = 90;
 		break;
 	default:
 		return NT_STATUS_INVALID_LEVEL;
@@ -107,29 +107,29 @@ NTSTATUS _echo_TestCall2(pipes_struct *p, uint16_t level, union echo_Info *info)
 	return NT_STATUS_OK;
 }
 
-uint32 _echo_TestSleep(pipes_struct *p, uint32_t seconds)
+uint32 _echo_TestSleep(pipes_struct *p, struct echo_TestSleep *r)
 {
-	sleep(seconds);
-	return seconds;
+	sleep(r->in.seconds);
+	return r->in.seconds;
 }
 
-void _echo_TestEnum(pipes_struct *p, enum echo_Enum1 *foo1, struct echo_Enum2 *foo2, union echo_Enum3 *foo3)
+void _echo_TestEnum(pipes_struct *p, struct echo_TestEnum *r)
 {
 }
 
-void _echo_TestSurrounding(pipes_struct *p, struct echo_Surrounding *data)
+void _echo_TestSurrounding(pipes_struct *p, struct echo_TestSurrounding *r)
 {
-	data->x *= 2;
-	data->surrounding = talloc_zero_array(p->mem_ctx, uint16_t, data->x);
+	r->out.data->x *= 2;
+	r->out.data->surrounding = talloc_zero_array(p->mem_ctx, uint16_t, r->in.data->x);
 }
 
-uint16 _echo_TestDoublePointer(pipes_struct *p, uint16_t ***data)
+uint16 _echo_TestDoublePointer(pipes_struct *p, struct echo_TestDoublePointer *r)
 {
-	if (!*data) 
+	if (!*r->in.data) 
 		return 0;
-	if (!**data)
+	if (!**r->in.data)
 		return 0;
-	return ***data;
+	return ***r->in.data;
 }
 
 #endif /* DEVELOPER */
diff --git a/source3/rpc_server/srv_initshutdown_nt.c b/source3/rpc_server/srv_initshutdown_nt.c
index a73077fe03..cd84f72058 100644
--- a/source3/rpc_server/srv_initshutdown_nt.c
+++ b/source3/rpc_server/srv_initshutdown_nt.c
@@ -30,24 +30,37 @@
 
 /*******************************************************************
  ********************************************************************/
-WERROR _initshutdown_Init(pipes_struct *p, uint16_t *hostname, struct initshutdown_String *message, uint32_t timeout, uint8_t force_apps, uint8_t reboot)
+WERROR _initshutdown_Init(pipes_struct *p, struct initshutdown_Init *r)
 {
-	uint32_t reason = 0;
+	struct winreg_InitiateSystemShutdownEx s;
+
+	s.in.hostname = r->in.hostname;
+	s.in.message = r->in.message;
+	s.in.timeout = r->in.timeout;
+	s.in.force_apps = r->in.force_apps;
+	s.in.reboot = r->in.reboot;
+	s.in.reason = 0;
 
 	/* thunk down to _winreg_InitiateSystemShutdownEx() 
 	   (just returns a status) */
 	
-	return _winreg_InitiateSystemShutdownEx( p, hostname, message, timeout, 
-		force_apps, reboot, reason );
+	return _winreg_InitiateSystemShutdownEx( p, &s );
 }
 
 /*******************************************************************
  ********************************************************************/
 
-WERROR _initshutdown_InitEx(pipes_struct *p, uint16_t *hostname, struct initshutdown_String *message, uint32_t timeout, uint8_t force_apps, uint8_t reboot, uint32_t reason)
+WERROR _initshutdown_InitEx(pipes_struct *p, struct initshutdown_InitEx *r)
 {
-	return _winreg_InitiateSystemShutdownEx( p, hostname, message, timeout, 
-		force_apps, reboot, reason );
+	struct winreg_InitiateSystemShutdownEx s;
+	s.in.hostname = r->in.hostname;
+	s.in.message = r->in.message;
+	s.in.timeout = r->in.timeout;
+	s.in.force_apps = r->in.force_apps;
+	s.in.reboot = r->in.reboot;
+	s.in.reason = r->in.reason;
+
+	return _winreg_InitiateSystemShutdownEx( p, &s);
 }
 
 
@@ -57,7 +70,9 @@ WERROR _initshutdown_InitEx(pipes_struct *p, uint16_t *hostname, struct initshut
  reg_abort_shutdwon
  ********************************************************************/
 
-WERROR _initshutdown_Abort(pipes_struct *p, uint16_t *server)
+WERROR _initshutdown_Abort(pipes_struct *p, struct initshutdown_Abort *r)
 {
-	return _winreg_AbortSystemShutdown( p, server );
+	struct winreg_AbortSystemShutdown s;
+	s.in.server = r->in.server;
+	return _winreg_AbortSystemShutdown( p, &s );
 }
diff --git a/source3/rpc_server/srv_lsa_nt.c b/source3/rpc_server/srv_lsa_nt.c
index 44ec292750..76ec38af6f 100644
--- a/source3/rpc_server/srv_lsa_nt.c
+++ b/source3/rpc_server/srv_lsa_nt.c
@@ -1296,22 +1296,20 @@ NTSTATUS _lsa_lookup_names4(pipes_struct *p, LSA_Q_LOOKUP_NAMES4 *q_u, LSA_R_LOO
  _lsa_close. Also weird - needs to check if lsa handle is correct. JRA.
  ***************************************************************************/
 
-NTSTATUS _lsa_Close(pipes_struct *p, struct policy_handle *handle)
+NTSTATUS _lsa_Close(pipes_struct *p, struct lsa_Close *r)
 {
-	if (!find_policy_by_hnd(p, handle, NULL)) {
+	if (!find_policy_by_hnd(p, r->in.handle, NULL)) {
 		return NT_STATUS_INVALID_HANDLE;
 	}
 
-	close_policy_hnd(p, handle);
+	close_policy_hnd(p, r->in.handle);
 	return NT_STATUS_OK;
 }
 
 /***************************************************************************
  ***************************************************************************/
 
-NTSTATUS _lsa_OpenSecret(pipes_struct *p, struct policy_handle *handle,
-			 struct lsa_String name, uint32_t access_mask,
-			 struct policy_handle *sec_handle)
+NTSTATUS _lsa_OpenSecret(pipes_struct *p, struct lsa_OpenSecret *r)
 {
 	return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 }
@@ -1319,9 +1317,7 @@ NTSTATUS _lsa_OpenSecret(pipes_struct *p, struct policy_handle *handle,
 /***************************************************************************
  ***************************************************************************/
 
-NTSTATUS _lsa_OpenTrustedDomain(pipes_struct *p, struct policy_handle *handle,
-				struct dom_sid2 *sid, uint32_t access_mask,
-				struct policy_handle *trustdom_handle)
+NTSTATUS _lsa_OpenTrustedDomain(pipes_struct *p, struct lsa_OpenTrustedDomain *r)
 {
 	return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 }
@@ -1329,11 +1325,7 @@ NTSTATUS _lsa_OpenTrustedDomain(pipes_struct *p, struct policy_handle *handle,
 /***************************************************************************
  ***************************************************************************/
 
-NTSTATUS _lsa_CreateTrustedDomain(pipes_struct *p,
-				  struct policy_handle *handle,
-				  struct lsa_DomainInfo *info,
-				  uint32_t access_mask,
-				  struct policy_handle *trustdom_handle)
+NTSTATUS _lsa_CreateTrustedDomain(pipes_struct *p, struct lsa_CreateTrustedDomain *r)
 {
 	return NT_STATUS_ACCESS_DENIED;
 }
@@ -1341,9 +1333,7 @@ NTSTATUS _lsa_CreateTrustedDomain(pipes_struct *p,
 /***************************************************************************
  ***************************************************************************/
 
-NTSTATUS _lsa_CreateSecret(pipes_struct *p, struct policy_handle *handle,
-			   struct lsa_String name, uint32_t access_mask,
-			   struct policy_handle *sec_handle)
+NTSTATUS _lsa_CreateSecret(pipes_struct *p, struct lsa_CreateSecret *r)
 {
 	return NT_STATUS_ACCESS_DENIED;
 }
@@ -1351,9 +1341,7 @@ NTSTATUS _lsa_CreateSecret(pipes_struct *p, struct policy_handle *handle,
 /***************************************************************************
  ***************************************************************************/
 
-NTSTATUS _lsa_SetSecret(pipes_struct *p, struct policy_handle *sec_handle,
-			struct lsa_DATA_BUF *new_val,
-			struct lsa_DATA_BUF *old_val)
+NTSTATUS _lsa_SetSecret(pipes_struct *p, struct lsa_SetSecret *r)
 {
 	return NT_STATUS_ACCESS_DENIED;
 }
@@ -2141,457 +2129,457 @@ NTSTATUS _lsa_lookup_priv_value(pipes_struct *p, LSA_Q_LOOKUP_PRIV_VALUE *q_u, L
  * pulling the server stubs across one by one.
  */ 
 
-NTSTATUS _lsa_Delete(pipes_struct *p, struct policy_handle *handle)
+NTSTATUS _lsa_Delete(pipes_struct *p, struct lsa_Delete *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_EnumPrivs(pipes_struct *p, struct policy_handle *handle, uint32_t *resume_handle, uint32_t max_count, struct lsa_PrivArray *_privs)
+NTSTATUS _lsa_EnumPrivs(pipes_struct *p, struct lsa_EnumPrivs *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_QuerySecurity(pipes_struct *p, struct policy_handle *handle, uint32_t sec_info, struct sec_desc_buf *sdbuf)
+NTSTATUS _lsa_QuerySecurity(pipes_struct *p, struct lsa_QuerySecurity *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_SetSecObj(pipes_struct *p)
+NTSTATUS _lsa_SetSecObj(pipes_struct *p, struct lsa_SetSecObj *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_ChangePassword(pipes_struct *p)
+NTSTATUS _lsa_ChangePassword(pipes_struct *p, struct lsa_ChangePassword *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_OpenPolicy(pipes_struct *p, uint16_t *system_name, struct lsa_ObjectAttribute *attr, uint32_t access_mask, struct policy_handle *handle)
+NTSTATUS _lsa_OpenPolicy(pipes_struct *p, struct lsa_OpenPolicy *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_QueryInfoPolicy(pipes_struct *p, struct policy_handle *handle, uint16_t level, union lsa_PolicyInformation *info)
+NTSTATUS _lsa_QueryInfoPolicy(pipes_struct *p, struct lsa_QueryInfoPolicy *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_SetInfoPolicy(pipes_struct *p)
+NTSTATUS _lsa_SetInfoPolicy(pipes_struct *p, struct lsa_SetInfoPolicy *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_ClearAuditLog(pipes_struct *p)
+NTSTATUS _lsa_ClearAuditLog(pipes_struct *p, struct lsa_ClearAuditLog *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_CreateAccount(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *sid, uint32_t access_mask, struct policy_handle *acct_handle)
+NTSTATUS _lsa_CreateAccount(pipes_struct *p, struct lsa_CreateAccount *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_EnumAccounts(pipes_struct *p, struct policy_handle *handle, uint32_t *resume_handle, uint32_t num_entries, struct lsa_SidArray *sids)
+NTSTATUS _lsa_EnumAccounts(pipes_struct *p, struct lsa_EnumAccounts *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_EnumTrustDom(pipes_struct *p, struct policy_handle *handle, uint32_t *resume_handle, uint32_t max_size, struct lsa_DomainList *domains)
+NTSTATUS _lsa_EnumTrustDom(pipes_struct *p, struct lsa_EnumTrustDom *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_LookupNames(pipes_struct *p, struct policy_handle *handle, uint32_t num_names, struct lsa_String *names, struct lsa_RefDomainList *domains, struct lsa_TransSidArray *sids, uint16_t level, uint32_t *count)
+NTSTATUS _lsa_LookupNames(pipes_struct *p, struct lsa_LookupNames *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_LookupSids(pipes_struct *p, struct policy_handle *handle, struct lsa_SidArray *sids, struct lsa_RefDomainList *domains, struct lsa_TransNameArray *names, uint16_t level, uint32_t *count)
+NTSTATUS _lsa_LookupSids(pipes_struct *p, struct lsa_LookupSids *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_OpenAccount(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *sid, uint32_t access_mask, struct policy_handle *acct_handle)
+NTSTATUS _lsa_OpenAccount(pipes_struct *p, struct lsa_OpenAccount *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_EnumPrivsAccount(pipes_struct *p, struct policy_handle *handle, struct lsa_PrivilegeSet *_privs)
+NTSTATUS _lsa_EnumPrivsAccount(pipes_struct *p, struct lsa_EnumPrivsAccount *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_AddPrivilegesToAccount(pipes_struct *p, struct policy_handle *handle, struct lsa_PrivilegeSet *_privs)
+NTSTATUS _lsa_AddPrivilegesToAccount(pipes_struct *p, struct lsa_AddPrivilegesToAccount *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_RemovePrivilegesFromAccount(pipes_struct *p, struct policy_handle *handle, uint8_t remove_all, struct lsa_PrivilegeSet *_privs)
+NTSTATUS _lsa_RemovePrivilegesFromAccount(pipes_struct *p, struct lsa_RemovePrivilegesFromAccount *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_GetQuotasForAccount(pipes_struct *p)
+NTSTATUS _lsa_GetQuotasForAccount(pipes_struct *p, struct lsa_GetQuotasForAccount *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_SetQuotasForAccount(pipes_struct *p)
+NTSTATUS _lsa_SetQuotasForAccount(pipes_struct *p, struct lsa_SetQuotasForAccount *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_GetSystemAccessAccount(pipes_struct *p)
+NTSTATUS _lsa_GetSystemAccessAccount(pipes_struct *p, struct lsa_GetSystemAccessAccount *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_SetSystemAccessAccount(pipes_struct *p)
+NTSTATUS _lsa_SetSystemAccessAccount(pipes_struct *p, struct lsa_SetSystemAccessAccount *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_QueryTrustedDomainInfo(pipes_struct *p, struct policy_handle *trustdom_handle, enum lsa_TrustDomInfoEnum level, union lsa_TrustedDomainInfo *info)
+NTSTATUS _lsa_QueryTrustedDomainInfo(pipes_struct *p, struct lsa_QueryTrustedDomainInfo *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_SetInformationTrustedDomain(pipes_struct *p)
+NTSTATUS _lsa_SetInformationTrustedDomain(pipes_struct *p, struct lsa_SetInformationTrustedDomain *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_QuerySecret(pipes_struct *p, struct policy_handle *sec_handle, struct lsa_DATA_BUF_PTR *new_val, NTTIME *new_mtime, struct lsa_DATA_BUF_PTR *old_val, NTTIME *old_mtime)
+NTSTATUS _lsa_QuerySecret(pipes_struct *p, struct lsa_QuerySecret *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_LookupPrivValue(pipes_struct *p, struct policy_handle *handle, struct lsa_String *name, struct lsa_LUID *luid)
+NTSTATUS _lsa_LookupPrivValue(pipes_struct *p, struct lsa_LookupPrivValue *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_LookupPrivName(pipes_struct *p, struct policy_handle *handle, struct lsa_LUID *luid, struct lsa_StringLarge *name)
+NTSTATUS _lsa_LookupPrivName(pipes_struct *p, struct lsa_LookupPrivName *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_LookupPrivDisplayName(pipes_struct *p, struct policy_handle *handle, struct lsa_String *name, struct lsa_StringLarge *disp_name, uint16_t *language_id, uint16_t unknown)
+NTSTATUS _lsa_LookupPrivDisplayName(pipes_struct *p, struct lsa_LookupPrivDisplayName *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_DeleteObject(pipes_struct *p)
+NTSTATUS _lsa_DeleteObject(pipes_struct *p, struct lsa_DeleteObject *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_EnumAccountsWithUserRight(pipes_struct *p, struct policy_handle *handle, struct lsa_String *name, struct lsa_SidArray *sids)
+NTSTATUS _lsa_EnumAccountsWithUserRight(pipes_struct *p, struct lsa_EnumAccountsWithUserRight *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_EnumAccountRights(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *sid, struct lsa_RightSet *rights)
+NTSTATUS _lsa_EnumAccountRights(pipes_struct *p, struct lsa_EnumAccountRights *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_AddAccountRights(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *sid, struct lsa_RightSet *rights)
+NTSTATUS _lsa_AddAccountRights(pipes_struct *p, struct lsa_AddAccountRights *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_RemoveAccountRights(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *sid, uint32_t unknown, struct lsa_RightSet *rights)
+NTSTATUS _lsa_RemoveAccountRights(pipes_struct *p, struct lsa_RemoveAccountRights *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_QueryTrustedDomainInfoBySid(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *dom_sid, enum lsa_TrustDomInfoEnum level, union lsa_TrustedDomainInfo *info)
+NTSTATUS _lsa_QueryTrustedDomainInfoBySid(pipes_struct *p, struct lsa_QueryTrustedDomainInfoBySid *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_SetTrustedDomainInfo(pipes_struct *p)
+NTSTATUS _lsa_SetTrustedDomainInfo(pipes_struct *p, struct lsa_SetTrustedDomainInfo *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_DeleteTrustedDomain(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *dom_sid)
+NTSTATUS _lsa_DeleteTrustedDomain(pipes_struct *p, struct lsa_DeleteTrustedDomain *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_StorePrivateData(pipes_struct *p)
+NTSTATUS _lsa_StorePrivateData(pipes_struct *p, struct lsa_StorePrivateData *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_RetrievePrivateData(pipes_struct *p)
+NTSTATUS _lsa_RetrievePrivateData(pipes_struct *p, struct lsa_RetrievePrivateData *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_OpenPolicy2(pipes_struct *p, const char *system_name, struct lsa_ObjectAttribute *attr, uint32_t access_mask, struct policy_handle *handle)
+NTSTATUS _lsa_OpenPolicy2(pipes_struct *p, struct lsa_OpenPolicy2 *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_GetUserName(pipes_struct *p, const char *system_name, struct lsa_String *account_name, struct lsa_StringPointer *authority_name)
+NTSTATUS _lsa_GetUserName(pipes_struct *p, struct lsa_GetUserName *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_QueryInfoPolicy2(pipes_struct *p, struct policy_handle *handle, uint16_t level, union lsa_PolicyInformation *info)
+NTSTATUS _lsa_QueryInfoPolicy2(pipes_struct *p, struct lsa_QueryInfoPolicy2 *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_SetInfoPolicy2(pipes_struct *p)
+NTSTATUS _lsa_SetInfoPolicy2(pipes_struct *p, struct lsa_SetInfoPolicy2 *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_QueryTrustedDomainInfoByName(pipes_struct *p, struct policy_handle *handle, struct lsa_String trusted_domain, enum lsa_TrustDomInfoEnum level, union lsa_TrustedDomainInfo *info)
+NTSTATUS _lsa_QueryTrustedDomainInfoByName(pipes_struct *p, struct lsa_QueryTrustedDomainInfoByName *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_SetTrustedDomainInfoByName(pipes_struct *p, struct policy_handle *handle, struct lsa_String trusted_domain, enum lsa_TrustDomInfoEnum level, union lsa_TrustedDomainInfo *info)
+NTSTATUS _lsa_SetTrustedDomainInfoByName(pipes_struct *p, struct lsa_SetTrustedDomainInfoByName *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_EnumTrustedDomainsEx(pipes_struct *p, struct policy_handle *handle, uint32_t *resume_handle, struct lsa_DomainListEx *domains, uint32_t max_size)
+NTSTATUS _lsa_EnumTrustedDomainsEx(pipes_struct *p, struct lsa_EnumTrustedDomainsEx *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_CreateTrustedDomainEx(pipes_struct *p)
+NTSTATUS _lsa_CreateTrustedDomainEx(pipes_struct *p, struct lsa_CreateTrustedDomainEx *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_CloseTrustedDomainEx(pipes_struct *p, struct policy_handle *handle)
+NTSTATUS _lsa_CloseTrustedDomainEx(pipes_struct *p, struct lsa_CloseTrustedDomainEx *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_QueryDomainInformationPolicy(pipes_struct *p, struct policy_handle *handle, uint16_t level, union lsa_DomainInformationPolicy *info)
+NTSTATUS _lsa_QueryDomainInformationPolicy(pipes_struct *p, struct lsa_QueryDomainInformationPolicy *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_SetDomainInformationPolicy(pipes_struct *p, struct policy_handle *handle, uint16_t level, union lsa_DomainInformationPolicy *info)
+NTSTATUS _lsa_SetDomainInformationPolicy(pipes_struct *p, struct lsa_SetDomainInformationPolicy *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_OpenTrustedDomainByName(pipes_struct *p, struct policy_handle *handle, struct lsa_String name, uint32_t access_mask, struct policy_handle *trustdom_handle)
+NTSTATUS _lsa_OpenTrustedDomainByName(pipes_struct *p, struct lsa_OpenTrustedDomainByName *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_TestCall(pipes_struct *p)
+NTSTATUS _lsa_TestCall(pipes_struct *p, struct lsa_TestCall *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_LookupSids2(pipes_struct *p, struct policy_handle *handle, struct lsa_SidArray *sids, struct lsa_RefDomainList *domains, struct lsa_TransNameArray2 *names, uint16_t level, uint32_t *count, uint32_t unknown1, uint32_t unknown2)
+NTSTATUS _lsa_LookupSids2(pipes_struct *p, struct lsa_LookupSids2 *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_LookupNames2(pipes_struct *p, struct policy_handle *handle, uint32_t num_names, struct lsa_String *names, struct lsa_RefDomainList *domains, struct lsa_TransSidArray2 *sids, uint16_t level, uint32_t *count, uint32_t unknown1, uint32_t unknown2)
+NTSTATUS _lsa_LookupNames2(pipes_struct *p, struct lsa_LookupNames2 *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_CreateTrustedDomainEx2(pipes_struct *p)
+NTSTATUS _lsa_CreateTrustedDomainEx2(pipes_struct *p, struct lsa_CreateTrustedDomainEx2 *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_CREDRWRITE(pipes_struct *p)
+NTSTATUS _lsa_CREDRWRITE(pipes_struct *p, struct lsa_CREDRWRITE *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_CREDRREAD(pipes_struct *p)
+NTSTATUS _lsa_CREDRREAD(pipes_struct *p, struct lsa_CREDRREAD *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_CREDRENUMERATE(pipes_struct *p)
+NTSTATUS _lsa_CREDRENUMERATE(pipes_struct *p, struct lsa_CREDRENUMERATE *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_CREDRWRITEDOMAINCREDENTIALS(pipes_struct *p)
+NTSTATUS _lsa_CREDRWRITEDOMAINCREDENTIALS(pipes_struct *p, struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_CREDRREADDOMAINCREDENTIALS(pipes_struct *p)
+NTSTATUS _lsa_CREDRREADDOMAINCREDENTIALS(pipes_struct *p, struct lsa_CREDRREADDOMAINCREDENTIALS *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_CREDRDELETE(pipes_struct *p)
+NTSTATUS _lsa_CREDRDELETE(pipes_struct *p, struct lsa_CREDRDELETE *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_CREDRGETTARGETINFO(pipes_struct *p)
+NTSTATUS _lsa_CREDRGETTARGETINFO(pipes_struct *p, struct lsa_CREDRGETTARGETINFO *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_CREDRPROFILELOADED(pipes_struct *p)
+NTSTATUS _lsa_CREDRPROFILELOADED(pipes_struct *p, struct lsa_CREDRPROFILELOADED *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_LookupNames3(pipes_struct *p, struct policy_handle *handle, uint32_t num_names, struct lsa_String *names, struct lsa_RefDomainList *domains, struct lsa_TransSidArray3 *sids, uint16_t level, uint32_t *count, uint32_t unknown1, uint32_t unknown2)
+NTSTATUS _lsa_LookupNames3(pipes_struct *p, struct lsa_LookupNames3 *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_CREDRGETSESSIONTYPES(pipes_struct *p)
+NTSTATUS _lsa_CREDRGETSESSIONTYPES(pipes_struct *p, struct lsa_CREDRGETSESSIONTYPES *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_LSARREGISTERAUDITEVENT(pipes_struct *p)
+NTSTATUS _lsa_LSARREGISTERAUDITEVENT(pipes_struct *p, struct lsa_LSARREGISTERAUDITEVENT *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_LSARGENAUDITEVENT(pipes_struct *p)
+NTSTATUS _lsa_LSARGENAUDITEVENT(pipes_struct *p, struct lsa_LSARGENAUDITEVENT *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_LSARUNREGISTERAUDITEVENT(pipes_struct *p)
+NTSTATUS _lsa_LSARUNREGISTERAUDITEVENT(pipes_struct *p, struct lsa_LSARUNREGISTERAUDITEVENT *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_LSARQUERYFORESTTRUSTINFORMATION(pipes_struct *p)
+NTSTATUS _lsa_LSARQUERYFORESTTRUSTINFORMATION(pipes_struct *p, struct lsa_LSARQUERYFORESTTRUSTINFORMATION *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_LSARSETFORESTTRUSTINFORMATION(pipes_struct *p)
+NTSTATUS _lsa_LSARSETFORESTTRUSTINFORMATION(pipes_struct *p, struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_CREDRRENAME(pipes_struct *p)
+NTSTATUS _lsa_CREDRRENAME(pipes_struct *p, struct lsa_CREDRRENAME *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_LookupSids3(pipes_struct *p, struct lsa_SidArray *sids, struct lsa_RefDomainList *domains, struct lsa_TransNameArray2 *names, uint16_t level, uint32_t *count, uint32_t unknown1, uint32_t unknown2)
+NTSTATUS _lsa_LookupSids3(pipes_struct *p, struct lsa_LookupSids3 *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_LookupNames4(pipes_struct *p, uint32_t num_names, struct lsa_String *names, struct lsa_RefDomainList *domains, struct lsa_TransSidArray3 *sids, uint16_t level, uint32_t *count, uint32_t unknown1, uint32_t unknown2)
+NTSTATUS _lsa_LookupNames4(pipes_struct *p, struct lsa_LookupNames4 *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_LSAROPENPOLICYSCE(pipes_struct *p)
+NTSTATUS _lsa_LSAROPENPOLICYSCE(pipes_struct *p, struct lsa_LSAROPENPOLICYSCE *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(pipes_struct *p)
+NTSTATUS _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(pipes_struct *p, struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(pipes_struct *p)
+NTSTATUS _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(pipes_struct *p, struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
 }
 
-NTSTATUS _lsa_LSARADTREPORTSECURITYEVENT(pipes_struct *p)
+NTSTATUS _lsa_LSARADTREPORTSECURITYEVENT(pipes_struct *p, struct lsa_LSARADTREPORTSECURITYEVENT *r)
 {
 	p->rng_fault_state = True;
 	return NT_STATUS_NOT_IMPLEMENTED;
diff --git a/source3/rpc_server/srv_srvsvc_nt.c b/source3/rpc_server/srv_srvsvc_nt.c
index a9adaf3200..06c84b60e9 100644
--- a/source3/rpc_server/srv_srvsvc_nt.c
+++ b/source3/rpc_server/srv_srvsvc_nt.c
@@ -1063,11 +1063,11 @@ static WERROR net_file_enum_3(pipes_struct *p, union srvsvc_NetFileCtr *ctr, uin
 /*******************************************************************
 *******************************************************************/
 
-WERROR _srvsvc_NetFileEnum(pipes_struct *p, const char *server_unc, const char *path, const char *user, uint32_t *level, union srvsvc_NetFileCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _srvsvc_NetFileEnum(pipes_struct *p, struct srvsvc_NetFileEnum *r)
 {
-	switch ( *level ) {
+	switch ( *r->in.level ) {
 	case 3:
-		return net_file_enum_3(p, ctr, resume_handle, totalentries );	
+		return net_file_enum_3(p, r->in.ctr, r->in.resume_handle, r->out.totalentries );	
 	default:
 		return WERR_UNKNOWN_LEVEL;
 	}
@@ -1079,11 +1079,11 @@ WERROR _srvsvc_NetFileEnum(pipes_struct *p, const char *server_unc, const char *
 net server get info
 ********************************************************************/
 
-WERROR _srvsvc_NetSrvGetInfo(pipes_struct *p, const char *server_unc, uint32_t level, union srvsvc_NetSrvInfo *info)
+WERROR _srvsvc_NetSrvGetInfo(pipes_struct *p, struct srvsvc_NetSrvGetInfo *r)
 {
 	WERROR status = WERR_OK;
 
-	ZERO_STRUCTP(info);
+	ZERO_STRUCTP(r->out.info);
 
 	DEBUG(5,("srv_net_srv_get_info: %d\n", __LINE__));
 
@@ -1092,42 +1092,42 @@ WERROR _srvsvc_NetSrvGetInfo(pipes_struct *p, const char *server_unc, uint32_t l
 		return WERR_ACCESS_DENIED;
 	}
 
-	switch (level) {
+	switch (r->in.level) {
 
 		/* Technically level 102 should only be available to
 		   Administrators but there isn't anything super-secret
 		   here, as most of it is made up. */
 
 	case 102:
-		info->info102 = talloc_zero(p->mem_ctx, struct srvsvc_NetSrvInfo102);
-
-		info->info102->platform_id = 500;
-		info->info102->version_major = lp_major_announce_version();
-		info->info102->version_minor = lp_minor_announce_version();
-		info->info102->server_name = global_myname(); 
-		info->info102->server_type = lp_default_server_announce();
-		info->info102->userpath = "C:\\";
-		info->info102->licenses = 10000;
-		info->info102->anndelta = 3000;
-		info->info102->disc = 0xf;
-		info->info102->users = 0xffffffff;
-		info->info102->hidden = 0;
-		info->info102->announce = 240;
-		info->info102->comment = lp_serverstring();
+		r->out.info->info102 = talloc_zero(p->mem_ctx, struct srvsvc_NetSrvInfo102);
+
+		r->out.info->info102->platform_id = 500;
+		r->out.info->info102->version_major = lp_major_announce_version();
+		r->out.info->info102->version_minor = lp_minor_announce_version();
+		r->out.info->info102->server_name = global_myname(); 
+		r->out.info->info102->server_type = lp_default_server_announce();
+		r->out.info->info102->userpath = "C:\\";
+		r->out.info->info102->licenses = 10000;
+		r->out.info->info102->anndelta = 3000;
+		r->out.info->info102->disc = 0xf;
+		r->out.info->info102->users = 0xffffffff;
+		r->out.info->info102->hidden = 0;
+		r->out.info->info102->announce = 240;
+		r->out.info->info102->comment = lp_serverstring();
 		break;
 	case 101:
-		info->info101 = talloc_zero(p->mem_ctx, struct srvsvc_NetSrvInfo101);
-			info->info101->platform_id = 500;
-			info->info101->server_name = global_myname();
-			info->info101->version_major = lp_major_announce_version();
-			info->info101->version_minor = lp_minor_announce_version();
-			info->info101->server_type = lp_default_server_announce();
-			info->info101->comment = lp_serverstring();
+		r->out.info->info101 = talloc_zero(p->mem_ctx, struct srvsvc_NetSrvInfo101);
+			r->out.info->info101->platform_id = 500;
+			r->out.info->info101->server_name = global_myname();
+			r->out.info->info101->version_major = lp_major_announce_version();
+			r->out.info->info101->version_minor = lp_minor_announce_version();
+			r->out.info->info101->server_type = lp_default_server_announce();
+			r->out.info->info101->comment = lp_serverstring();
 		break;
 	case 100:
-		info->info100 = talloc_zero(p->mem_ctx, struct srvsvc_NetSrvInfo100);
-		info->info100->platform_id = 500;
-		info->info100->server_name = global_myname();
+		r->out.info->info100 = talloc_zero(p->mem_ctx, struct srvsvc_NetSrvInfo100);
+		r->out.info->info100->platform_id = 500;
+		r->out.info->info100->server_name = global_myname();
 		break;
 	default:
 		return WERR_UNKNOWN_LEVEL;
@@ -1143,11 +1143,11 @@ WERROR _srvsvc_NetSrvGetInfo(pipes_struct *p, const char *server_unc, uint32_t l
 net server set info
 ********************************************************************/
 
-WERROR _srvsvc_NetSrvSetInfo(pipes_struct *p, const char *server_unc, uint32_t level, union srvsvc_NetSrvInfo info, uint32_t *parm_error)
+WERROR _srvsvc_NetSrvSetInfo(pipes_struct *p, struct srvsvc_NetSrvSetInfo *r)
 {
 	/* Set up the net server set info structure. */
-	if (parm_error) {
-		*parm_error = 0;
+	if (r->out.parm_error) {
+		*r->out.parm_error = 0;
 	}
 	return WERR_OK;
 }
@@ -1156,44 +1156,44 @@ WERROR _srvsvc_NetSrvSetInfo(pipes_struct *p, const char *server_unc, uint32_t l
 net conn enum
 ********************************************************************/
 
-WERROR _srvsvc_NetConnEnum(pipes_struct *p, const char *server_unc, const char *path, uint32_t *level, union srvsvc_NetConnCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _srvsvc_NetConnEnum(pipes_struct *p, struct srvsvc_NetConnEnum *r)
 {
 	DEBUG(5,("srv_net_conn_enum: %d\n", __LINE__));
 
-	ZERO_STRUCTP(ctr);
+	ZERO_STRUCTP(r->out.ctr);
 
 	/* set up the */
-	return init_srv_conn_info_ctr(p, ctr, *level, resume_handle, totalentries);
+	return init_srv_conn_info_ctr(p, r->out.ctr, *r->in.level, r->in.resume_handle, r->out.totalentries);
 }
 
 /*******************************************************************
 net sess enum
 ********************************************************************/
 
-WERROR _srvsvc_NetSessEnum(pipes_struct *p, const char *server_unc, const char *client, const char *user, uint32_t *level, union srvsvc_NetSessCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _srvsvc_NetSessEnum(pipes_struct *p, struct srvsvc_NetSessEnum *r)
 {
 	DEBUG(5,("_srv_net_sess_enum: %d\n", __LINE__));
 
-	ZERO_STRUCTP(ctr);
+	ZERO_STRUCTP(r->out.ctr);
 
 	/* set up the */
-	return init_srv_sess_info_ctr(p, ctr,
-				*level, 
-				resume_handle,
-				totalentries);
+	return init_srv_sess_info_ctr(p, r->out.ctr,
+				*r->in.level, 
+				r->in.resume_handle,
+				r->out.totalentries);
 }
 
 /*******************************************************************
 net sess del
 ********************************************************************/
 
-WERROR _srvsvc_NetSessDel(pipes_struct *p, const char *server_unc, const char *client, const char *user)
+WERROR _srvsvc_NetSessDel(pipes_struct *p, struct srvsvc_NetSessDel *r)
 {
 	struct sessionid *session_list;
 	int num_sessions, snum;
 	WERROR status;
 
-	char *machine = talloc_strdup(p->mem_ctx, server_unc);
+	char *machine = talloc_strdup(p->mem_ctx, r->in.server_unc);
 
 	/* strip leading backslashes if any */
 	while (machine[0] == '\\') {
@@ -1216,8 +1216,8 @@ WERROR _srvsvc_NetSessDel(pipes_struct *p, const char *server_unc, const char *c
 
 	for (snum = 0; snum < num_sessions; snum++) {
 
-		if ((strequal(session_list[snum].username, user) || user[0] == '\0' ) &&
-		    strequal(session_list[snum].remote_machine, machine)) {
+		if ((strequal(session_list[snum].username, r->in.user) || r->in.user[0] == '\0' ) &&
+		     strequal(session_list[snum].remote_machine, machine)) {
 		
 			if (message_send_pid(pid_to_procid(session_list[snum].pid), MSG_SHUTDOWN, NULL, 0, False))
 				status = WERR_OK;
@@ -1237,7 +1237,7 @@ done:
  Net share enum all.
 ********************************************************************/
 
-WERROR _srvsvc_NetShareEnumAll(pipes_struct *p, const char *server_unc, uint32_t *level, union srvsvc_NetShareCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _srvsvc_NetShareEnumAll(pipes_struct *p, struct srvsvc_NetShareEnumAll *r)
 {
 	DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
 
@@ -1247,15 +1247,15 @@ WERROR _srvsvc_NetShareEnumAll(pipes_struct *p, const char *server_unc, uint32_t
 	}
 
 	/* Create the list of shares for the response. */
-	return init_srv_share_info_ctr(p, ctr, *level,
-					      resume_handle, totalentries, True);
+	return init_srv_share_info_ctr(p, r->out.ctr, *r->in.level,
+					      r->in.resume_handle, r->out.totalentries, True);
 }
 
 /*******************************************************************
  Net share enum.
 ********************************************************************/
 
-WERROR _srvsvc_NetShareEnum(pipes_struct *p, const char *server_unc, uint32_t *level, union srvsvc_NetShareCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _srvsvc_NetShareEnum(pipes_struct *p, struct srvsvc_NetShareEnum *r)
 {
 	DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
 
@@ -1265,79 +1265,72 @@ WERROR _srvsvc_NetShareEnum(pipes_struct *p, const char *server_unc, uint32_t *l
 	}
 
 	/* Create the list of shares for the response. */
-	return init_srv_share_info_ctr(p, ctr, *level,
-					      resume_handle, totalentries, False);
+	return init_srv_share_info_ctr(p, r->out.ctr, *r->in.level,
+					      r->in.resume_handle, r->out.totalentries, False);
 }
 
 /*******************************************************************
  Net share get info.
 ********************************************************************/
 
-WERROR _srvsvc_NetShareGetInfo(pipes_struct *p, const char *server_unc, const char *share_name, uint32_t level, union srvsvc_NetShareInfo *info)
+WERROR _srvsvc_NetShareGetInfo(pipes_struct *p, struct srvsvc_NetShareGetInfo *r)
 {
 	const struct share_params *params;
 
-	params = get_share_params(p->mem_ctx, share_name);
+	params = get_share_params(p->mem_ctx, r->in.share_name);
 
 	if (params != NULL) {
-		switch (level) {
+		switch (r->in.level) {
 		case 0:
-			info->info0 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo0);
-			init_srv_share_info_0(p, info->info0,
-					      params);
+			r->out.info->info0 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo0);
+			init_srv_share_info_0(p, r->out.info->info0, params);
 			break;
 		case 1:
-			info->info1 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1);
-			init_srv_share_info_1(p, info->info1,
-					      params);
+			r->out.info->info1 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1);
+			init_srv_share_info_1(p, r->out.info->info1, params);
 			break;
 		case 2:
-			info->info2 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo2);
-			init_srv_share_info_2(p, info->info2,
-					      params);
+			r->out.info->info2 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo2);
+			init_srv_share_info_2(p, r->out.info->info2, params);
 			break;
 		case 501:
-			info->info501 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo501);
-			init_srv_share_info_501(p, info->info501,
-						params);
+			r->out.info->info501 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo501);
+			init_srv_share_info_501(p, r->out.info->info501, params);
 			break;
 		case 502:
-			info->info502 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo502);
-			init_srv_share_info_502(p, info->info502,
-						params);
+			r->out.info->info502 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo502);
+			init_srv_share_info_502(p, r->out.info->info502, params);
 			break;
 
 			/* here for completeness */
 		case 1004:
-			info->info1004 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1004);
-			init_srv_share_info_1004(p, info->info1004,
-						 params);
+			r->out.info->info1004 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1004);
+			init_srv_share_info_1004(p, r->out.info->info1004, params);
 			break;
 		case 1005:
-			info->info1005 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1005);
-			init_srv_share_info_1005(p, info->info1005,
-						 params);
+			r->out.info->info1005 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1005);
+			init_srv_share_info_1005(p, r->out.info->info1005, params);
 			break;
 
 			/* here for completeness 1006 - 1501 */
 		case 1006:
-			info->info1006 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1006);
-			init_srv_share_info_1006(p, info->info1006,
+			r->out.info->info1006 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1006);
+			init_srv_share_info_1006(p, r->out.info->info1006,
 						 params);
 			break;
 		case 1007:
-			info->info1007 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1007);
-			init_srv_share_info_1007(p, info->info1007,
+			r->out.info->info1007 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1007);
+			init_srv_share_info_1007(p, r->out.info->info1007,
 						 params);
 			break;
 		case 1501:
-			info->info1501 = talloc(p->mem_ctx, struct sec_desc_buf);
-			init_srv_share_info_1501(p, info->info1501,
+			r->out.info->info1501 = talloc(p->mem_ctx, struct sec_desc_buf);
+			init_srv_share_info_1501(p, r->out.info->info1501,
 						 params);
 			break;
 		default:
 			DEBUG(5,("init_srv_net_share_get_info: unsupported "
-				 "switch value %d\n", level));
+				 "switch value %d\n", r->in.level));
 			return WERR_UNKNOWN_LEVEL;
 			break;
 		}
@@ -1630,10 +1623,7 @@ static WERROR change_share(const char *share_name, const char *path,
  Net share set info. Modify share details.
 ********************************************************************/
 
-WERROR _srvsvc_NetShareSetInfo(pipes_struct *p, const char *server_unc,
-			       const char *share_name, uint32_t level,
-			       union srvsvc_NetShareInfo info,
-			       uint32_t *parm_error)
+WERROR _srvsvc_NetShareSetInfo(pipes_struct *p, struct srvsvc_NetShareSetInfo *r)
 {
 	pstring comment;
 	pstring pathname;
@@ -1648,18 +1638,18 @@ WERROR _srvsvc_NetShareSetInfo(pipes_struct *p, const char *server_unc,
 
 	DEBUG(5,("_srv_net_share_set_info: %d\n", __LINE__));
 
-	if (parm_error) {
-		*parm_error = 0;
+	if (r->out.parm_error) {
+		*r->out.parm_error = 0;
 	}
 
-	if ( strequal(share_name,"IPC$") 
-		|| ( lp_enable_asu_support() && strequal(share_name,"ADMIN$") )
-		|| strequal(share_name,"global") )
+	if ( strequal(r->in.share_name,"IPC$") 
+		|| ( lp_enable_asu_support() && strequal(r->in.share_name,"ADMIN$") )
+		|| strequal(r->in.share_name,"global") )
 	{
 		return WERR_ACCESS_DENIED;
 	}
 
-	fstrcpy(tmp_share_name, share_name);
+	fstrcpy(tmp_share_name, r->in.share_name);
 	snum = find_service(tmp_share_name);
 
 	/* Does this share exist ? */
@@ -1678,31 +1668,31 @@ WERROR _srvsvc_NetShareSetInfo(pipes_struct *p, const char *server_unc,
 	if ( p->pipe_user.ut.uid != sec_initial_uid() && !is_disk_op )
 		return WERR_ACCESS_DENIED;
 
-	switch (level) {
+	switch (r->in.level) {
 	case 1:
 		pstrcpy(pathname, lp_pathname(snum));
-		pstrcpy(comment, info.info1->comment);
-		type = info.info1->type;
+		pstrcpy(comment, r->in.info.info1->comment);
+		type = r->in.info.info1->type;
 		psd = NULL;
 		break;
 	case 2:
-		pstrcpy(comment, info.info2->comment);
-		pstrcpy(pathname, info.info2->path);
-		type = info.info2->type;
-		max_connections = (info.info2->max_users == 0xffffffff) ?
-			0 : info.info2->max_users;
+		pstrcpy(comment, r->in.info.info2->comment);
+		pstrcpy(pathname, r->in.info.info2->path);
+		type = r->in.info.info2->type;
+		max_connections = (r->in.info.info2->max_users == 0xffffffff) ?
+			0 : r->in.info.info2->max_users;
 		psd = NULL;
 		break;
 	case 502:
-		pstrcpy(comment, info.info502->comment);
-		pstrcpy(pathname, info.info502->path);
-		type = info.info502->type;
-		psd = info.info502->sd;
+		pstrcpy(comment, r->in.info.info502->comment);
+		pstrcpy(pathname, r->in.info.info502->path);
+		type = r->in.info.info502->type;
+		psd = r->in.info.info502->sd;
 		map_generic_share_sd_bits(psd);
 		break;
 	case 1004:
 		pstrcpy(pathname, lp_pathname(snum));
-		pstrcpy(comment, info.info1004->comment);
+		pstrcpy(comment, r->in.info.info1004->comment);
 		type = STYPE_DISKTREE;
 		break;
 	case 1005:
@@ -1710,7 +1700,7 @@ WERROR _srvsvc_NetShareSetInfo(pipes_struct *p, const char *server_unc,
 		   user, so we must compare it to see if it's what is set in
 		   smb.conf, so that we can contine other ops like setting
 		   ACLs on a share */
-		if (((info.info1005->dfs_flags &
+		if (((r->in.info.info1005->dfs_flags &
 		      SHARE_1005_CSC_POLICY_MASK) >>
 		     SHARE_1005_CSC_POLICY_SHIFT) == lp_csc_policy(snum))
 			return WERR_OK;
@@ -1726,13 +1716,13 @@ WERROR _srvsvc_NetShareSetInfo(pipes_struct *p, const char *server_unc,
 	case 1501:
 		pstrcpy(pathname, lp_pathname(snum));
 		pstrcpy(comment, lp_comment(snum));
-		psd = info.info1501->sd;
+		psd = r->in.info.info1501->sd;
 		map_generic_share_sd_bits(psd);
 		type = STYPE_DISKTREE;
 		break;
 	default:
 		DEBUG(5,("_srv_net_share_set_info: unsupported switch value "
-			 "%d\n", level));
+			 "%d\n", r->in.level));
 		return WERR_UNKNOWN_LEVEL;
 	}
 
@@ -1778,10 +1768,10 @@ WERROR _srvsvc_NetShareSetInfo(pipes_struct *p, const char *server_unc,
 					    &sd_size);
 
 		if (old_sd && !sec_desc_equal(old_sd, psd)) {
-			if (!set_share_security(share_name, psd)) {
+			if (!set_share_security(r->in.share_name, psd)) {
 				DEBUG(0,("_srv_net_share_set_info: Failed to "
 					 "change security info in share %s.\n",
-					 share_name ));
+					 r->in.share_name ));
 			}
 		}
 	}
@@ -1797,9 +1787,7 @@ WERROR _srvsvc_NetShareSetInfo(pipes_struct *p, const char *server_unc,
  "comment" "max connections = "
 ********************************************************************/
 
-WERROR _srvsvc_NetShareAdd(pipes_struct *p, const char *server_unc,
-			   uint32_t level, union srvsvc_NetShareInfo info,
-			   uint32_t *parm_error)
+WERROR _srvsvc_NetShareAdd(pipes_struct *p, struct srvsvc_NetShareAdd *r)
 {
 	pstring share_name;
 	pstring comment;
@@ -1814,8 +1802,8 @@ WERROR _srvsvc_NetShareAdd(pipes_struct *p, const char *server_unc,
 
 	DEBUG(5,("_srv_net_share_add: %d\n", __LINE__));
 
-	if (parm_error) {
-		*parm_error = 0;
+	if (r->out.parm_error) {
+		*r->out.parm_error = 0;
 	}
 
 	is_disk_op = user_has_privileges( p->pipe_user.nt_user_token,
@@ -1824,7 +1812,7 @@ WERROR _srvsvc_NetShareAdd(pipes_struct *p, const char *server_unc,
 	if (p->pipe_user.ut.uid != sec_initial_uid()  && !is_disk_op ) 
 		return WERR_ACCESS_DENIED;
 
-	switch (level) {
+	switch (r->in.level) {
 	case 0:
 		/* No path. Not enough info in a level 0 to do anything. */
 		return WERR_ACCESS_DENIED;
@@ -1832,22 +1820,22 @@ WERROR _srvsvc_NetShareAdd(pipes_struct *p, const char *server_unc,
 		/* Not enough info in a level 1 to do anything. */
 		return WERR_ACCESS_DENIED;
 	case 2:
-		pstrcpy(share_name, info.info2->name);
-		pstrcpy(comment, info.info2->comment);
-		pstrcpy(pathname, info.info2->path);
-		max_connections = (info.info2->max_users == 0xffffffff) ?
-			0 : info.info2->max_users;
-		type = info.info2->type;
+		pstrcpy(share_name, r->in.info.info2->name);
+		pstrcpy(comment, r->in.info.info2->comment);
+		pstrcpy(pathname, r->in.info.info2->path);
+		max_connections = (r->in.info.info2->max_users == 0xffffffff) ?
+			0 : r->in.info.info2->max_users;
+		type = r->in.info.info2->type;
 		break;
 	case 501:
 		/* No path. Not enough info in a level 501 to do anything. */
 		return WERR_ACCESS_DENIED;
 	case 502:
-		pstrcpy(share_name, info.info502->name);
-		pstrcpy(comment, info.info502->comment);
-		pstrcpy(pathname, info.info502->path);
-		type = info.info502->type;
-		psd = info.info502->sd;
+		pstrcpy(share_name, r->in.info.info502->name);
+		pstrcpy(comment, r->in.info.info502->comment);
+		pstrcpy(pathname, r->in.info.info502->path);
+		type = r->in.info.info502->type;
+		psd = r->in.info.info502->sd;
 		map_generic_share_sd_bits(psd);
 		break;
 
@@ -1864,7 +1852,7 @@ WERROR _srvsvc_NetShareAdd(pipes_struct *p, const char *server_unc,
 		return WERR_ACCESS_DENIED;
 	default:
 		DEBUG(5,("_srv_net_share_add: unsupported switch value %d\n",
-			 level));
+			 r->in.level));
 		return WERR_UNKNOWN_LEVEL;
 	}
 
@@ -1933,8 +1921,7 @@ WERROR _srvsvc_NetShareAdd(pipes_struct *p, const char *server_unc,
  a parameter.
 ********************************************************************/
 
-WERROR _srvsvc_NetShareDel(pipes_struct *p, const char *server_unc,
-			   const char *share_name, uint32_t reserved)
+WERROR _srvsvc_NetShareDel(pipes_struct *p, struct srvsvc_NetShareDel *r)
 {
 	struct share_params *params;
 	SE_PRIV se_diskop = SE_DISK_OPERATOR;
@@ -1943,14 +1930,14 @@ WERROR _srvsvc_NetShareDel(pipes_struct *p, const char *server_unc,
 
 	DEBUG(5,("_srv_net_share_del: %d\n", __LINE__));
 
-	if ( strequal(share_name,"IPC$") 
-	     || ( lp_enable_asu_support() && strequal(share_name,"ADMIN$") )
-	     || strequal(share_name,"global") )
+	if ( strequal(r->in.share_name, "IPC$") 
+	     || ( lp_enable_asu_support() && strequal(r->in.share_name,"ADMIN$") )
+	     || strequal(r->in.share_name, "global") )
 	{
 		return WERR_ACCESS_DENIED;
 	}
 
-	if (!(params = get_share_params(p->mem_ctx, share_name))) {
+	if (!(params = get_share_params(p->mem_ctx, r->in.share_name))) {
 		return WERR_NO_SUCH_SHARE;
 	}
 
@@ -1979,19 +1966,24 @@ WERROR _srvsvc_NetShareDel(pipes_struct *p, const char *server_unc,
 	return WERR_OK;
 }
 
-WERROR _srvsvc_NetShareDelSticky(pipes_struct *p, const char *server_unc,
-				 const char *share_name, uint32_t reserved)
+WERROR _srvsvc_NetShareDelSticky(pipes_struct *p, struct srvsvc_NetShareDelSticky *r)
 {
+	struct srvsvc_NetShareDel s;
+
 	DEBUG(5,("_srv_net_share_del_stick: %d\n", __LINE__));
 
-	return _srvsvc_NetShareDel(p, server_unc, share_name, reserved);
+	s.in.server_unc = r->in.server_unc;
+	s.in.share_name = r->in.share_name;
+	s.in.reserved = r->in.reserved;
+
+	return _srvsvc_NetShareDel(p, &s);
 }
 
 /*******************************************************************
 time of day
 ********************************************************************/
 
-WERROR _srvsvc_NetRemoteTOD(pipes_struct *p, const char *server_unc, struct srvsvc_NetRemoteTODInfo *tod)
+WERROR _srvsvc_NetRemoteTOD(pipes_struct *p, struct srvsvc_NetRemoteTOD *r)
 {
 	struct tm *t;
 	time_t unixdate = time(NULL);
@@ -2007,18 +1999,18 @@ WERROR _srvsvc_NetRemoteTOD(pipes_struct *p, const char *server_unc, struct srvs
 	t = gmtime(&unixdate);
 
 	/* set up the */
-	tod->elapsed = unixdate;
-	tod->msecs = 0;
-	tod->hours = t->tm_hour;
-	tod->mins = t->tm_min;
-	tod->secs = t->tm_sec;
-	tod->hunds = 0;
-	tod->timezone = zone;
-	tod->tinterval = 10000;
-	tod->day = t->tm_mday;
-	tod->month = t->tm_mon + 1;
-	tod->year = 1900+t->tm_year;
-	tod->weekday = t->tm_wday;
+	r->out.info->elapsed = unixdate;
+	r->out.info->msecs = 0;
+	r->out.info->hours = t->tm_hour;
+	r->out.info->mins = t->tm_min;
+	r->out.info->secs = t->tm_sec;
+	r->out.info->hunds = 0;
+	r->out.info->timezone = zone;
+	r->out.info->tinterval = 10000;
+	r->out.info->day = t->tm_mday;
+	r->out.info->month = t->tm_mon + 1;
+	r->out.info->year = 1900+t->tm_year;
+	r->out.info->weekday = t->tm_wday;
 	
 	DEBUG(5,("_srv_net_remote_tod: %d\n", __LINE__));
 
@@ -2029,7 +2021,7 @@ WERROR _srvsvc_NetRemoteTOD(pipes_struct *p, const char *server_unc, struct srvs
  Win9x NT tools get security descriptor.
 ***********************************************************************************/
 
-WERROR _srvsvc_NetGetFileSecurity(pipes_struct *p, const char *server_unc, const char *share, const char *file, uint32_t securityinformation, struct sec_desc_buf *sd_buf)
+WERROR _srvsvc_NetGetFileSecurity(pipes_struct *p, struct srvsvc_NetGetFileSecurity *r)
 {
 	SEC_DESC *psd = NULL;
 	size_t sd_size;
@@ -2049,11 +2041,11 @@ WERROR _srvsvc_NetGetFileSecurity(pipes_struct *p, const char *server_unc, const
 	null_pw = data_blob(NULL, 0);
 
 	become_root();
-	conn = make_connection(share, null_pw, "A:", p->pipe_user.vuid, &nt_status);
+	conn = make_connection(r->in.share, null_pw, "A:", p->pipe_user.vuid, &nt_status);
 	unbecome_root();
 
 	if (conn == NULL) {
-		DEBUG(3,("_srv_net_file_query_secdesc: Unable to connect to %s\n", share));
+		DEBUG(3,("_srv_net_file_query_secdesc: Unable to connect to %s\n", r->in.share));
 		status = ntstatus_to_werror(nt_status);
 		goto error_exit;
 	}
@@ -2065,26 +2057,26 @@ WERROR _srvsvc_NetGetFileSecurity(pipes_struct *p, const char *server_unc, const
 	}
 	became_user = True;
 
-	pstrcpy(tmp_file, file);
+	pstrcpy(tmp_file, r->in.file);
 	nt_status = unix_convert(conn, tmp_file, False, NULL, &st);
 	if (!NT_STATUS_IS_OK(nt_status)) {
-		DEBUG(3,("_srv_net_file_query_secdesc: bad pathname %s\n", file));
+		DEBUG(3,("_srv_net_file_query_secdesc: bad pathname %s\n", r->in.file));
 		status = WERR_ACCESS_DENIED;
 		goto error_exit;
 	}
 
-	nt_status = check_name(conn, file);
+	nt_status = check_name(conn, r->in.file);
 	if (!NT_STATUS_IS_OK(nt_status)) {
-		DEBUG(3,("_srv_net_file_query_secdesc: can't access %s\n", file));
+		DEBUG(3,("_srv_net_file_query_secdesc: can't access %s\n", r->in.file));
 		status = WERR_ACCESS_DENIED;
 		goto error_exit;
 	}
 
-	nt_status = open_file_stat(conn, file, &st, &fsp);
+	nt_status = open_file_stat(conn, r->in.file, &st, &fsp);
 	if (!NT_STATUS_IS_OK(nt_status)) {
 		/* Perhaps it is a directory */
 		if (NT_STATUS_EQUAL(nt_status, NT_STATUS_FILE_IS_A_DIRECTORY))
-			nt_status = open_directory(conn, file, &st,
+			nt_status = open_directory(conn, r->in.file, &st,
 					READ_CONTROL_ACCESS,
 					FILE_SHARE_READ|FILE_SHARE_WRITE,
 					FILE_OPEN,
@@ -2092,7 +2084,7 @@ WERROR _srvsvc_NetGetFileSecurity(pipes_struct *p, const char *server_unc, const
 					NULL, &fsp);
 
 		if (!NT_STATUS_IS_OK(nt_status)) {
-			DEBUG(3,("_srv_net_file_query_secdesc: Unable to open file %s\n", file));
+			DEBUG(3,("_srv_net_file_query_secdesc: Unable to open file %s\n", r->in.file));
 			status = WERR_ACCESS_DENIED;
 			goto error_exit;
 		}
@@ -2101,13 +2093,13 @@ WERROR _srvsvc_NetGetFileSecurity(pipes_struct *p, const char *server_unc, const
 	sd_size = SMB_VFS_GET_NT_ACL(fsp, fsp->fsp_name, (OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION), &psd);
 
 	if (sd_size == 0) {
-		DEBUG(3,("_srv_net_file_query_secdesc: Unable to get NT ACL for file %s\n", file));
+		DEBUG(3,("_srv_net_file_query_secdesc: Unable to get NT ACL for file %s\n", r->in.file));
 		status = WERR_ACCESS_DENIED;
 		goto error_exit;
 	}
 
-	sd_buf->sd_size= sd_size;
-	sd_buf->sd = psd;
+	r->out.sd_buf->sd_size= sd_size;
+	r->out.sd_buf->sd = psd;
 
 	psd->dacl->revision = (uint16) NT4_ACL_REVISION;
 
@@ -2135,7 +2127,7 @@ error_exit:
  Win9x NT tools set security descriptor.
 ***********************************************************************************/
 
-WERROR _srvsvc_NetSetFileSecurity(pipes_struct *p, const char *server_unc, const char *share, const char *file, uint32_t securityinformation, struct sec_desc_buf sd_buf)
+WERROR _srvsvc_NetSetFileSecurity(pipes_struct *p, struct srvsvc_NetSetFileSecurity *r)
 {
 	BOOL ret;
 	DATA_BLOB null_pw;
@@ -2153,11 +2145,11 @@ WERROR _srvsvc_NetSetFileSecurity(pipes_struct *p, const char *server_unc, const
 	null_pw = data_blob(NULL, 0);
 
 	become_root();
-	conn = make_connection(share, null_pw, "A:", p->pipe_user.vuid, &nt_status);
+	conn = make_connection(r->in.share, null_pw, "A:", p->pipe_user.vuid, &nt_status);
 	unbecome_root();
 
 	if (conn == NULL) {
-		DEBUG(3,("_srv_net_file_set_secdesc: Unable to connect to %s\n", share));
+		DEBUG(3,("_srv_net_file_set_secdesc: Unable to connect to %s\n", r->in.share));
 		status = ntstatus_to_werror(nt_status);
 		goto error_exit;
 	}
@@ -2169,28 +2161,28 @@ WERROR _srvsvc_NetSetFileSecurity(pipes_struct *p, const char *server_unc, const
 	}
 	became_user = True;
 
-	pstrcpy(tmp_file, file);
+	pstrcpy(tmp_file, r->in.file);
 	nt_status = unix_convert(conn, tmp_file, False, NULL, &st);
 	if (!NT_STATUS_IS_OK(nt_status)) {
-		DEBUG(3,("_srv_net_file_set_secdesc: bad pathname %s\n", file));
+		DEBUG(3,("_srv_net_file_set_secdesc: bad pathname %s\n", r->in.file));
 		status = WERR_ACCESS_DENIED;
 		goto error_exit;
 	}
 
-	nt_status = check_name(conn, file);
+	nt_status = check_name(conn, r->in.file);
 	if (!NT_STATUS_IS_OK(nt_status)) {
-		DEBUG(3,("_srv_net_file_set_secdesc: can't access %s\n", file));
+		DEBUG(3,("_srv_net_file_set_secdesc: can't access %s\n", r->in.file));
 		status = WERR_ACCESS_DENIED;
 		goto error_exit;
 	}
 
 
-	nt_status = open_file_stat(conn, file, &st, &fsp);
+	nt_status = open_file_stat(conn, r->in.file, &st, &fsp);
 
 	if (!NT_STATUS_IS_OK(nt_status)) {
 		/* Perhaps it is a directory */
 		if (NT_STATUS_EQUAL(nt_status, NT_STATUS_FILE_IS_A_DIRECTORY))
-			nt_status = open_directory(conn, file, &st,
+			nt_status = open_directory(conn, r->in.file, &st,
 						FILE_READ_ATTRIBUTES,
 						FILE_SHARE_READ|FILE_SHARE_WRITE,
 						FILE_OPEN,
@@ -2198,16 +2190,16 @@ WERROR _srvsvc_NetSetFileSecurity(pipes_struct *p, const char *server_unc, const
 						NULL, &fsp);
 
 		if (!NT_STATUS_IS_OK(nt_status)) {
-			DEBUG(3,("_srv_net_file_set_secdesc: Unable to open file %s\n", file));
+			DEBUG(3,("_srv_net_file_set_secdesc: Unable to open file %s\n", r->in.file));
 			status = WERR_ACCESS_DENIED;
 			goto error_exit;
 		}
 	}
 
-	ret = SMB_VFS_SET_NT_ACL(fsp, fsp->fsp_name, securityinformation, sd_buf.sd);
+	ret = SMB_VFS_SET_NT_ACL(fsp, fsp->fsp_name, r->in.securityinformation, r->in.sd_buf.sd);
 
 	if (ret == False) {
-		DEBUG(3,("_srv_net_file_set_secdesc: Unable to set NT ACL on file %s\n", file));
+		DEBUG(3,("_srv_net_file_set_secdesc: Unable to set NT ACL on file %s\n", r->in.file));
 		status = WERR_ACCESS_DENIED;
 		goto error_exit;
 	}
@@ -2280,38 +2272,38 @@ static const char *next_server_disk_enum(uint32 *resume)
 	return disk;
 }
 
-WERROR _srvsvc_NetDiskEnum(pipes_struct *p, const char *server_unc, uint32_t level, struct srvsvc_NetDiskInfo *info, uint32_t maxlen, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _srvsvc_NetDiskEnum(pipes_struct *p, struct srvsvc_NetDiskEnum *r)
 {
 	uint32 i;
 	const char *disk_name;
 
 	WERROR status = WERR_OK;
 
-	*totalentries = init_server_disk_enum(resume_handle);
-	info->count = 0;
+	*r->out.totalentries = init_server_disk_enum(r->in.resume_handle);
+	r->out.info->count = 0;
 
-	if(!(info->disks =  TALLOC_ARRAY(p->mem_ctx, struct srvsvc_NetDiskInfo0, MAX_SERVER_DISK_ENTRIES))) {
+	if(!(r->out.info->disks =  TALLOC_ARRAY(p->mem_ctx, struct srvsvc_NetDiskInfo0, MAX_SERVER_DISK_ENTRIES))) {
 		return WERR_NOMEM;
 	}
 
 	/*allow one struct srvsvc_NetDiskInfo0 for null terminator*/
 
-	for(i = 0; i < MAX_SERVER_DISK_ENTRIES -1 && (disk_name = next_server_disk_enum(resume_handle)); i++) {
+	for(i = 0; i < MAX_SERVER_DISK_ENTRIES -1 && (disk_name = next_server_disk_enum(r->in.resume_handle)); i++) {
 
-		info->count++;
-		(*totalentries)++;
+		r->out.info->count++;
+		(*r->out.totalentries)++;
 
 		/*copy disk name into a unicode string*/
 
-		info->disks[i].disk = disk_name; 
+		r->out.info->disks[i].disk = disk_name; 
 	}
 
 	/* add a terminating null string.  Is this there if there is more data to come? */
 
-	info->count++;
-	(*totalentries)++;
+	r->out.info->count++;
+	(*r->out.totalentries)++;
 
-	info->disks[i].disk = "";
+	r->out.info->disks[i].disk = "";
 
 	return status;
 }
@@ -2319,29 +2311,29 @@ WERROR _srvsvc_NetDiskEnum(pipes_struct *p, const char *server_unc, uint32_t lev
 /********************************************************************
 ********************************************************************/
 
-WERROR _srvsvc_NetNameValidate(pipes_struct *p, const char *server_unc, const char *name, uint32_t name_type, uint32_t flags)
+WERROR _srvsvc_NetNameValidate(pipes_struct *p, struct srvsvc_NetNameValidate *r)
 {
 	int len;
 
-	if ((flags != 0x0) && (flags != 0x80000000)) {
+	if ((r->in.flags != 0x0) && (r->in.flags != 0x80000000)) {
 		return WERR_INVALID_PARAM;
 	}
 
-	switch ( name_type ) {
+	switch ( r->in.name_type ) {
 	case 0x9:
-		len = strlen_m(name);
+		len = strlen_m(r->in.name);
 
-		if ((flags == 0x0) && (len > 81)) {
-			DEBUG(5,("_srv_net_name_validate: share name too long (%s > 81 chars)\n", name));
+		if ((r->in.flags == 0x0) && (len > 81)) {
+			DEBUG(5,("_srv_net_name_validate: share name too long (%s > 81 chars)\n", r->in.name));
 			return WERR_INVALID_NAME;
 		}
-		if ((flags == 0x80000000) && (len > 13)) {
-			DEBUG(5,("_srv_net_name_validate: share name too long (%s > 13 chars)\n", name));
+		if ((r->in.flags == 0x80000000) && (len > 13)) {
+			DEBUG(5,("_srv_net_name_validate: share name too long (%s > 13 chars)\n", r->in.name));
 			return WERR_INVALID_NAME;
 		}
 
-		if ( ! validate_net_name( name, INVALID_SHARENAME_CHARS, sizeof(name) ) ) {
-			DEBUG(5,("_srv_net_name_validate: Bad sharename \"%s\"\n", name));
+		if ( ! validate_net_name( r->in.name, INVALID_SHARENAME_CHARS, sizeof(r->in.name) ) ) {
+			DEBUG(5,("_srv_net_name_validate: Bad sharename \"%s\"\n", r->in.name));
 			return WERR_INVALID_NAME;
 		}
 		break;
@@ -2357,216 +2349,216 @@ WERROR _srvsvc_NetNameValidate(pipes_struct *p, const char *server_unc, const ch
 /********************************************************************
 ********************************************************************/
 
-WERROR _srvsvc_NetFileClose(pipes_struct *p, const char *server_unc, uint32_t fid)
+WERROR _srvsvc_NetFileClose(pipes_struct *p, struct srvsvc_NetFileClose *r)
 {
 	return WERR_ACCESS_DENIED;
 }
 
-WERROR _srvsvc_NetCharDevEnum(pipes_struct *p, const char *server_unc, uint32_t *level, union srvsvc_NetCharDevCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _srvsvc_NetCharDevEnum(pipes_struct *p, struct srvsvc_NetCharDevEnum *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetCharDevGetInfo(pipes_struct *p, const char *server_unc, const char *device_name, uint32_t level, union srvsvc_NetCharDevInfo *info)
+WERROR _srvsvc_NetCharDevGetInfo(pipes_struct *p, struct srvsvc_NetCharDevGetInfo *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetCharDevControl(pipes_struct *p, const char *server_unc, const char *device_name, uint32_t opcode)
+WERROR _srvsvc_NetCharDevControl(pipes_struct *p, struct srvsvc_NetCharDevControl *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetCharDevQEnum(pipes_struct *p, const char *server_unc, const char *user, uint32_t *level, union srvsvc_NetCharDevQCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _srvsvc_NetCharDevQEnum(pipes_struct *p, struct srvsvc_NetCharDevQEnum *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetCharDevQGetInfo(pipes_struct *p, const char *server_unc, const char *queue_name, const char *user, uint32_t level, union srvsvc_NetCharDevQInfo *info)
+WERROR _srvsvc_NetCharDevQGetInfo(pipes_struct *p, struct srvsvc_NetCharDevQGetInfo *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetCharDevQSetInfo(pipes_struct *p, const char *server_unc, const char *queue_name, uint32_t level, union srvsvc_NetCharDevQInfo info, uint32_t *parm_error)
+WERROR _srvsvc_NetCharDevQSetInfo(pipes_struct *p, struct srvsvc_NetCharDevQSetInfo *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetCharDevQPurge(pipes_struct *p, const char *server_unc, const char *queue_name)
+WERROR _srvsvc_NetCharDevQPurge(pipes_struct *p, struct srvsvc_NetCharDevQPurge *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetCharDevQPurgeSelf(pipes_struct *p, const char *server_unc, const char *queue_name, const char *computer_name)
+WERROR _srvsvc_NetCharDevQPurgeSelf(pipes_struct *p, struct srvsvc_NetCharDevQPurgeSelf *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetFileGetInfo(pipes_struct *p, const char *server_unc, uint32_t fid, uint32_t level, union srvsvc_NetFileInfo *info)
+WERROR _srvsvc_NetFileGetInfo(pipes_struct *p, struct srvsvc_NetFileGetInfo *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetShareCheck(pipes_struct *p, const char *server_unc, const char *device_name, enum srvsvc_ShareType *type)
+WERROR _srvsvc_NetShareCheck(pipes_struct *p, struct srvsvc_NetShareCheck *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetServerStatisticsGet(pipes_struct *p, const char *server_unc, const char *service, uint32_t level, uint32_t options, struct srvsvc_Statistics *stats)
+WERROR _srvsvc_NetServerStatisticsGet(pipes_struct *p, struct srvsvc_NetServerStatisticsGet *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetTransportAdd(pipes_struct *p, const char *server_unc, uint32_t level, union srvsvc_NetTransportInfo info)
+WERROR _srvsvc_NetTransportAdd(pipes_struct *p, struct srvsvc_NetTransportAdd *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetTransportEnum(pipes_struct *p, const char *server_unc, uint32_t *level, union srvsvc_NetTransportCtr *transports, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _srvsvc_NetTransportEnum(pipes_struct *p, struct srvsvc_NetTransportEnum *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetTransportDel(pipes_struct *p, const char *server_unc, uint32_t unknown, struct srvsvc_NetTransportInfo0 transport)
+WERROR _srvsvc_NetTransportDel(pipes_struct *p, struct srvsvc_NetTransportDel *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetSetServiceBits(pipes_struct *p, const char *server_unc, const char *transport, uint32_t servicebits, uint32_t updateimmediately)
+WERROR _srvsvc_NetSetServiceBits(pipes_struct *p, struct srvsvc_NetSetServiceBits *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetPathType(pipes_struct *p, const char *server_unc, const char *path, uint32_t pathflags, uint32_t *pathtype)
+WERROR _srvsvc_NetPathType(pipes_struct *p, struct srvsvc_NetPathType *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetPathCanonicalize(pipes_struct *p, const char *server_unc, const char *path, uint8_t *can_path, uint32_t maxbuf, const char *prefix, uint32_t *pathtype, uint32_t pathflags)
+WERROR _srvsvc_NetPathCanonicalize(pipes_struct *p, struct srvsvc_NetPathCanonicalize *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetPathCompare(pipes_struct *p, const char *server_unc, const char *path1, const char *path2, uint32_t pathtype, uint32_t pathflags)
+WERROR _srvsvc_NetPathCompare(pipes_struct *p, struct srvsvc_NetPathCompare *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NETRPRNAMECANONICALIZE(pipes_struct *p)
+WERROR _srvsvc_NETRPRNAMECANONICALIZE(pipes_struct *p, struct srvsvc_NETRPRNAMECANONICALIZE *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetPRNameCompare(pipes_struct *p, const char *server_unc, const char *name1, const char *name2, uint32_t name_type, uint32_t flags)
+WERROR _srvsvc_NetPRNameCompare(pipes_struct *p, struct srvsvc_NetPRNameCompare *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetShareDelStart(pipes_struct *p, const char *server_unc, const char *share, uint32_t reserved, struct policy_handle *hnd)
+WERROR _srvsvc_NetShareDelStart(pipes_struct *p, struct srvsvc_NetShareDelStart *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetShareDelCommit(pipes_struct *p, struct policy_handle *hnd)
+WERROR _srvsvc_NetShareDelCommit(pipes_struct *p, struct srvsvc_NetShareDelCommit *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetServerTransportAddEx(pipes_struct *p, const char *server_unc, uint32_t level, union srvsvc_NetTransportInfo info)
+WERROR _srvsvc_NetServerTransportAddEx(pipes_struct *p, struct srvsvc_NetServerTransportAddEx *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NetServerSetServiceBitsEx(pipes_struct *p, const char *server_unc, const char *emulated_server_unc, const char *transport, uint32_t servicebitsofinterest, uint32_t servicebits, uint32_t updateimmediately)
+WERROR _srvsvc_NetServerSetServiceBitsEx(pipes_struct *p, struct srvsvc_NetServerSetServiceBitsEx *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NETRDFSGETVERSION(pipes_struct *p)
+WERROR _srvsvc_NETRDFSGETVERSION(pipes_struct *p, struct srvsvc_NETRDFSGETVERSION *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NETRDFSCREATELOCALPARTITION(pipes_struct *p)
+WERROR _srvsvc_NETRDFSCREATELOCALPARTITION(pipes_struct *p, struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NETRDFSDELETELOCALPARTITION(pipes_struct *p)
+WERROR _srvsvc_NETRDFSDELETELOCALPARTITION(pipes_struct *p, struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NETRDFSSETLOCALVOLUMESTATE(pipes_struct *p)
+WERROR _srvsvc_NETRDFSSETLOCALVOLUMESTATE(pipes_struct *p, struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *R)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NETRDFSSETSERVERINFO(pipes_struct *p)
+WERROR _srvsvc_NETRDFSSETSERVERINFO(pipes_struct *p, struct srvsvc_NETRDFSSETSERVERINFO *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NETRDFSCREATEEXITPOINT(pipes_struct *p)
+WERROR _srvsvc_NETRDFSCREATEEXITPOINT(pipes_struct *p, struct srvsvc_NETRDFSCREATEEXITPOINT *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NETRDFSDELETEEXITPOINT(pipes_struct *p)
+WERROR _srvsvc_NETRDFSDELETEEXITPOINT(pipes_struct *p, struct srvsvc_NETRDFSDELETEEXITPOINT *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NETRSERVERTRANSPORTDELEX(pipes_struct *p)
+WERROR _srvsvc_NETRSERVERTRANSPORTDELEX(pipes_struct *p, struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NETRDFSMANAGERREPORTSITEINFO(pipes_struct *p)
+WERROR _srvsvc_NETRDFSMANAGERREPORTSITEINFO(pipes_struct *p, struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NETRDFSMODIFYPREFIX(pipes_struct *p)
+WERROR _srvsvc_NETRDFSMODIFYPREFIX(pipes_struct *p, struct srvsvc_NETRDFSMODIFYPREFIX *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
 }
 
-WERROR _srvsvc_NETRDFSFIXLOCALVOLUME(pipes_struct *p)
+WERROR _srvsvc_NETRDFSFIXLOCALVOLUME(pipes_struct *p, struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
 {
 	p->rng_fault_state = True;
 	return WERR_NOT_SUPPORTED;
diff --git a/source3/rpc_server/srv_unixinfo_nt.c b/source3/rpc_server/srv_unixinfo_nt.c
index 5dd5215ed0..565d96e1fc 100644
--- a/source3/rpc_server/srv_unixinfo_nt.c
+++ b/source3/rpc_server/srv_unixinfo_nt.c
@@ -30,26 +30,26 @@
 
 /* Map a sid to a uid */
 
-NTSTATUS _unixinfo_SidToUid(pipes_struct *p, struct dom_sid sid, uint64_t *uid)
+NTSTATUS _unixinfo_SidToUid(pipes_struct *p, struct unixinfo_SidToUid *r)
 {
 	uid_t real_uid;
 	NTSTATUS status;
-	*uid = 0;
+	*r->out.uid = 0;
 
-	status = sid_to_uid(&sid, &real_uid) ? NT_STATUS_OK : NT_STATUS_NONE_MAPPED;
+	status = sid_to_uid(&r->in.sid, &real_uid) ? NT_STATUS_OK : NT_STATUS_NONE_MAPPED;
 	if (NT_STATUS_IS_OK(status))
-		*uid = real_uid;
+		*r->out.uid = real_uid;
 
 	return status;
 }
 
 /* Map a uid to a sid */
 
-NTSTATUS _unixinfo_UidToSid(pipes_struct *p, uint64_t uid, struct dom_sid *sid)
+NTSTATUS _unixinfo_UidToSid(pipes_struct *p, struct unixinfo_UidToSid *r)
 {
 	NTSTATUS status = NT_STATUS_NO_SUCH_USER;
 
-	uid_to_sid(sid, (uid_t)uid);
+	uid_to_sid(r->out.sid, (uid_t)r->in.uid);
 	status = NT_STATUS_OK;
 
 	return status;
@@ -57,27 +57,27 @@ NTSTATUS _unixinfo_UidToSid(pipes_struct *p, uint64_t uid, struct dom_sid *sid)
 
 /* Map a sid to a gid */
 
-NTSTATUS _unixinfo_SidToGid(pipes_struct *p, struct dom_sid sid, uint64_t *gid)
+NTSTATUS _unixinfo_SidToGid(pipes_struct *p, struct unixinfo_SidToGid *r)
 {
 	gid_t real_gid;
 	NTSTATUS status;
 
-	*gid = 0;
+	*r->out.gid = 0;
 
-	status = sid_to_gid(&sid, &real_gid) ? NT_STATUS_OK : NT_STATUS_NONE_MAPPED;
+	status = sid_to_gid(&r->in.sid, &real_gid) ? NT_STATUS_OK : NT_STATUS_NONE_MAPPED;
 	if (NT_STATUS_IS_OK(status))
-		*gid = real_gid;
+		*r->out.gid = real_gid;
 
 	return status;
 }
 
 /* Map a gid to a sid */
 
-NTSTATUS _unixinfo_GidToSid(pipes_struct *p, uint64_t gid, struct dom_sid *sid)
+NTSTATUS _unixinfo_GidToSid(pipes_struct *p, struct unixinfo_GidToSid *r)
 {
 	NTSTATUS status = NT_STATUS_NO_SUCH_GROUP;
 
-	gid_to_sid(sid, (gid_t)gid);
+	gid_to_sid(r->out.sid, (gid_t)r->in.gid);
 	status = NT_STATUS_OK;
 
 	return status;
@@ -85,31 +85,30 @@ NTSTATUS _unixinfo_GidToSid(pipes_struct *p, uint64_t gid, struct dom_sid *sid)
 
 /* Get unix struct passwd information */
 
-NTSTATUS _unixinfo_GetPWUid(pipes_struct *p, uint32_t *count, uint64_t *uids, 
-							struct unixinfo_GetPWUidInfo *infos)
+NTSTATUS _unixinfo_GetPWUid(pipes_struct *p, struct unixinfo_GetPWUid *r)
 {
 	int i;
 	NTSTATUS status;
 
-	if (*count > 1023)
+	if (*r->in.count > 1023)
 		return NT_STATUS_INVALID_PARAMETER;
 
 	status = NT_STATUS_OK;
 
-	for (i=0; i<*count; i++) {
+	for (i=0; i<*r->in.count; i++) {
 		struct passwd *pw;
 		char *homedir, *shell;
 		ssize_t len1, len2;
 
-		infos[i].status = NT_STATUS_NO_SUCH_USER;
-		infos[i].homedir = "";
-		infos[i].shell = "";
+		r->out.infos[i].status = NT_STATUS_NO_SUCH_USER;
+		r->out.infos[i].homedir = "";
+		r->out.infos[i].shell = "";
 
-		pw = getpwuid(uids[i]);
+		pw = getpwuid(r->in.uids[i]);
 
 		if (pw == NULL) {
 			DEBUG(10, ("Did not find uid %lld\n",
-				   (long long int)uids[i]));
+				   (long long int)r->in.uids[i]));
 			continue;
 		}
 
@@ -119,13 +118,13 @@ NTSTATUS _unixinfo_GetPWUid(pipes_struct *p, uint32_t *count, uint64_t *uids,
 		if ((len1 < 0) || (len2 < 0) || (homedir == NULL) ||
 		    (shell == NULL)) {
 			DEBUG(3, ("push_utf8_talloc failed\n"));
-			infos[i].status = NT_STATUS_NO_MEMORY;
+			r->out.infos[i].status = NT_STATUS_NO_MEMORY;
 			continue;
 		}
 
-		infos[i].status = NT_STATUS_OK;
-		infos[i].homedir = homedir;
-		infos[i].shell = shell;
+		r->out.infos[i].status = NT_STATUS_OK;
+		r->out.infos[i].homedir = homedir;
+		r->out.infos[i].shell = shell;
 	}
 
 	return status;
diff --git a/source3/rpc_server/srv_winreg_nt.c b/source3/rpc_server/srv_winreg_nt.c
index 4006b375b5..404210a416 100644
--- a/source3/rpc_server/srv_winreg_nt.c
+++ b/source3/rpc_server/srv_winreg_nt.c
@@ -119,14 +119,14 @@ static BOOL close_registry_key(pipes_struct *p, POLICY_HND *hnd)
  reg_close
  ********************************************************************/
 
-WERROR _winreg_CloseKey(pipes_struct *p, struct policy_handle *handle)
+WERROR _winreg_CloseKey(pipes_struct *p, struct winreg_CloseKey *r)
 {
 	/* close the policy handle */
 
-	if (!close_registry_key(p, handle))
+	if (!close_registry_key(p, r->in.handle))
 		return WERR_BADFID; 
 
-	ZERO_STRUCTP(handle);
+	ZERO_STRUCTP(r->out.handle);
 
 	return WERR_OK;
 }
@@ -134,110 +134,97 @@ WERROR _winreg_CloseKey(pipes_struct *p, struct policy_handle *handle)
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_OpenHKLM(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKLM(pipes_struct *p, struct winreg_OpenHKLM *r)
 {
-	return open_registry_key(p, handle, NULL, KEY_HKLM, access_mask);
+	return open_registry_key(p, r->out.handle, NULL, KEY_HKLM, r->in.access_mask);
 }
 
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_OpenHKPD(pipes_struct *p, uint16_t *system_name,
-			uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKPD(pipes_struct *p, struct winreg_OpenHKPD *r)
 {
-	return open_registry_key(p, handle, NULL, KEY_HKPD, access_mask);
+	return open_registry_key(p, r->out.handle, NULL, KEY_HKPD, r->in.access_mask);
 }
 
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_OpenHKPT(pipes_struct *p, uint16_t *system_name,
-			uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKPT(pipes_struct *p, struct winreg_OpenHKPT *r)
 {
-	return open_registry_key(p, handle, NULL, KEY_HKPT, access_mask);
+	return open_registry_key(p, r->out.handle, NULL, KEY_HKPT, r->in.access_mask);
 }
 
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_OpenHKCR(pipes_struct *p, uint16_t *system_name,
-			uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKCR(pipes_struct *p, struct winreg_OpenHKCR *r)
 {
-	return open_registry_key(p, handle, NULL, KEY_HKCR, access_mask);
+	return open_registry_key(p, r->out.handle, NULL, KEY_HKCR, r->in.access_mask);
 }
 
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_OpenHKU(pipes_struct *p, uint16_t *system_name,
-		       uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKU(pipes_struct *p, struct winreg_OpenHKU *r)
 {
-	return open_registry_key(p, handle, NULL, KEY_HKU, access_mask);
+	return open_registry_key(p, r->out.handle, NULL, KEY_HKU, r->in.access_mask);
 }
 
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_OpenHKCU(pipes_struct *p, uint16_t *system_name,
-			uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKCU(pipes_struct *p, struct winreg_OpenHKCU *r)
 {
-	return open_registry_key(p, handle, NULL, KEY_HKCU, access_mask);
+	return open_registry_key(p, r->out.handle, NULL, KEY_HKCU, r->in.access_mask);
 }
 
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_OpenHKCC(pipes_struct *p, uint16_t *system_name,
-			uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKCC(pipes_struct *p, struct winreg_OpenHKCC *r)
 {
-	return open_registry_key(p, handle, NULL, KEY_HKCC, access_mask);
+	return open_registry_key(p, r->out.handle, NULL, KEY_HKCC, r->in.access_mask);
 }
 
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_OpenHKDD(pipes_struct *p, uint16_t *system_name,
-			uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKDD(pipes_struct *p, struct winreg_OpenHKDD *r)
 {
-	return open_registry_key(p, handle, NULL, KEY_HKDD, access_mask);
+	return open_registry_key(p, r->out.handle, NULL, KEY_HKDD, r->in.access_mask);
 }
 
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_OpenHKPN(pipes_struct *p, uint16_t *system_name,
-			uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKPN(pipes_struct *p, struct winreg_OpenHKPN *r)
 {
-	return open_registry_key(p, handle, NULL, KEY_HKPN, access_mask);
+	return open_registry_key(p, r->out.handle, NULL, KEY_HKPN, r->in.access_mask);
 }
 
 /*******************************************************************
  reg_reply_open_entry
  ********************************************************************/
 
-WERROR _winreg_OpenKey(pipes_struct *p, struct policy_handle *parent_handle,
-		       struct winreg_String keyname, uint32_t unknown,
-		       uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenKey(pipes_struct *p, struct winreg_OpenKey *r)
 {
-	struct registry_key *parent = find_regkey_by_hnd(p, parent_handle );
+	struct registry_key *parent = find_regkey_by_hnd(p, r->in.parent_handle );
 
 	if ( !parent )
 		return WERR_BADFID;
 
-	return open_registry_key(p, handle, parent, keyname.name, access_mask);
+	return open_registry_key(p, r->out.handle, parent, r->in.keyname.name, r->in.access_mask);
 }
 
 /*******************************************************************
  reg_reply_info
  ********************************************************************/
 
-WERROR _winreg_QueryValue(pipes_struct *p, struct policy_handle *handle,
-			  struct winreg_String value_name,
-			  enum winreg_Type *type, uint8_t *data,
-			  uint32_t *data_size, uint32_t *value_length)
+WERROR _winreg_QueryValue(pipes_struct *p, struct winreg_QueryValue *r)
 {
 	WERROR        status = WERR_BADFILE;
-	struct registry_key *regkey = find_regkey_by_hnd( p, handle );
+	struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
 	prs_struct    prs_hkpd;
 
 	uint8_t *outbuf;
@@ -250,7 +237,7 @@ WERROR _winreg_QueryValue(pipes_struct *p, struct policy_handle *handle,
 	if ( !regkey )
 		return WERR_BADFID;
 
-	*value_length = *type = 0;
+	*r->out.value_length = *r->out.type = 0;
 	
 	DEBUG(7,("_reg_info: policy key name = [%s]\n", regkey->key->name));
 	DEBUG(7,("_reg_info: policy key type = [%08x]\n", regkey->key->type));
@@ -258,54 +245,54 @@ WERROR _winreg_QueryValue(pipes_struct *p, struct policy_handle *handle,
 	/* Handle QueryValue calls on HKEY_PERFORMANCE_DATA */
 	if(regkey->key->type == REG_KEY_HKPD) 
 	{
-		if(strequal(value_name.name, "Global"))	{
-			prs_init(&prs_hkpd, *data_size, p->mem_ctx, MARSHALL);
+		if(strequal(r->in.value_name.name, "Global"))	{
+			prs_init(&prs_hkpd, *r->in.data_size, p->mem_ctx, MARSHALL);
 			status = reg_perfcount_get_hkpd(
-				&prs_hkpd, *data_size, &outbuf_size, NULL);
+				&prs_hkpd, *r->in.data_size, &outbuf_size, NULL);
 			outbuf = (uint8_t *)prs_hkpd.data_p;
 			free_prs = True;
 		}
-		else if(strequal(value_name.name, "Counter 009")) {
+		else if(strequal(r->in.value_name.name, "Counter 009")) {
 			outbuf_size = reg_perfcount_get_counter_names(
 				reg_perfcount_get_base_index(),
 				(char **)(void *)&outbuf);
 			free_buf = True;
 		}
-		else if(strequal(value_name.name, "Explain 009")) {
+		else if(strequal(r->in.value_name.name, "Explain 009")) {
 			outbuf_size = reg_perfcount_get_counter_help(
 				reg_perfcount_get_base_index(),
 				(char **)(void *)&outbuf);
 			free_buf = True;
 		}
-		else if(isdigit(value_name.name[0])) {
+		else if(isdigit(r->in.value_name.name[0])) {
 			/* we probably have a request for a specific object
 			 * here */
-			prs_init(&prs_hkpd, *data_size, p->mem_ctx, MARSHALL);
+			prs_init(&prs_hkpd, *r->in.data_size, p->mem_ctx, MARSHALL);
 			status = reg_perfcount_get_hkpd(
-				&prs_hkpd, *data_size, &outbuf_size,
-				value_name.name);
+				&prs_hkpd, *r->in.data_size, &outbuf_size,
+				r->in.value_name.name);
 			outbuf = (uint8_t *)prs_hkpd.data_p;
 			free_prs = True;
 		}
 		else {
 			DEBUG(3,("Unsupported key name [%s] for HKPD.\n",
-				 value_name.name));
+				 r->in.value_name.name));
 			return WERR_BADFILE;
 		}
 
-		*type = REG_BINARY;
+		*r->out.type = REG_BINARY;
 	}
 	else {
 		struct registry_value *val;
 
-		status = reg_queryvalue(p->mem_ctx, regkey, value_name.name,
+		status = reg_queryvalue(p->mem_ctx, regkey, r->in.value_name.name,
 					&val);
 		if (!W_ERROR_IS_OK(status)) {
-			if (data_size) {
-				*data_size = 0;
+			if (r->out.data_size) {
+				*r->out.data_size = 0;
 			}
-			if (value_length) {
-				*value_length = 0;
+			if (r->out.value_length) {
+				*r->out.value_length = 0;
 			}
 			return status;
 		}
@@ -317,21 +304,21 @@ WERROR _winreg_QueryValue(pipes_struct *p, struct policy_handle *handle,
 
 		outbuf = val_blob.data;
 		outbuf_size = val_blob.length;
-		*type = val->type;
+		*r->out.type = val->type;
 	}
 
-	*value_length = outbuf_size;
+	*r->out.value_length = outbuf_size;
 
-	if ( *data_size == 0 || !data ) {
+	if ( *r->in.data_size == 0 || !r->out.data ) {
 		status = WERR_OK;
-	} else if ( *value_length > *data_size ) {
+	} else if ( *r->out.value_length > *r->in.data_size ) {
 		status = WERR_MORE_DATA;
 	} else {
-		memcpy( data, outbuf, *value_length );
+		memcpy( r->out.data, outbuf, *r->out.value_length );
 		status = WERR_OK;
 	}
 
-	*data_size = *value_length;
+	*r->out.data_size = *r->out.value_length;
 
 	if (free_prs) prs_mem_free(&prs_hkpd);
 	if (free_buf) SAFE_FREE(outbuf);
@@ -343,26 +330,20 @@ WERROR _winreg_QueryValue(pipes_struct *p, struct policy_handle *handle,
  Implementation of REG_QUERY_KEY
  ****************************************************************************/
 
-WERROR _winreg_QueryInfoKey(pipes_struct *p, struct policy_handle *handle, 
-			    struct winreg_String *classname, 
-			    uint32_t *num_subkeys, uint32_t *max_subkeylen, 
-			    uint32_t *max_subkeysize, 
-			    uint32_t *num_values, uint32_t *max_valnamelen, 
-			    uint32_t *max_valbufsize, 
-			    uint32_t *secdescsize, NTTIME *last_changed_time)
+WERROR _winreg_QueryInfoKey(pipes_struct *p, struct winreg_QueryInfoKey *r)
 {
 	WERROR 	status = WERR_OK;
-	struct registry_key *regkey = find_regkey_by_hnd( p, handle );
+	struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
 	
 	if ( !regkey )
 		return WERR_BADFID;
 
-	classname->name = NULL;
+	r->out.classname->name = NULL;
 
-	status = reg_queryinfokey(regkey, num_subkeys, max_subkeylen,
-				  max_subkeysize, num_values, max_valnamelen,
-				  max_valbufsize, secdescsize,
-				  last_changed_time);
+	status = reg_queryinfokey(regkey, r->out.num_subkeys, r->out.max_subkeylen,
+				  r->out.max_classlen, r->out.num_values, r->out.max_valnamelen,
+				  r->out.max_valbufsize, r->out.secdescsize,
+				  r->out.last_changed_time);
 	if (!W_ERROR_IS_OK(status)) {
 		return status;
 	}
@@ -372,10 +353,10 @@ WERROR _winreg_QueryInfoKey(pipes_struct *p, struct policy_handle *handle,
 	 * UTF-16. They are inexact at best, but so far they worked.
 	 */
 
-	*max_subkeylen *= 2;
+	*r->out.max_subkeylen *= 2;
 
-	*max_valnamelen += 1;
-	*max_valnamelen *= 2;
+	*r->out.max_valnamelen += 1;
+	*r->out.max_valnamelen *= 2;
 	
 	return WERR_OK;
 }
@@ -385,14 +366,14 @@ WERROR _winreg_QueryInfoKey(pipes_struct *p, struct policy_handle *handle,
  Implementation of REG_GETVERSION
  ****************************************************************************/
  
-WERROR _winreg_GetVersion(pipes_struct *p, struct policy_handle *handle, uint32_t *version)
+WERROR _winreg_GetVersion(pipes_struct *p, struct winreg_GetVersion *r)
 {
-	struct registry_key *regkey = find_regkey_by_hnd( p, handle );
+	struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
 	
 	if ( !regkey )
 		return WERR_BADFID;
 	
-	*version = 0x00000005;	/* Windows 2000 registry API version */
+	*r->out.version = 0x00000005;	/* Windows 2000 registry API version */
 	
 	return WERR_OK;
 }
@@ -402,25 +383,25 @@ WERROR _winreg_GetVersion(pipes_struct *p, struct policy_handle *handle, uint32_
  Implementation of REG_ENUM_KEY
  ****************************************************************************/
  
-WERROR _winreg_EnumKey(pipes_struct *p, struct policy_handle *handle, uint32_t enum_index, struct winreg_StringBuf *name, struct winreg_StringBuf *keyclass, NTTIME *last_changed_time)
+WERROR _winreg_EnumKey(pipes_struct *p, struct winreg_EnumKey *r)
 {
 	WERROR err;
-	struct registry_key *key = find_regkey_by_hnd( p, handle );
+	struct registry_key *key = find_regkey_by_hnd( p, r->in.handle );
 	
 	if ( !key )
 		return WERR_BADFID; 
 
-	if ( !name || !keyclass )
+	if ( !r->in.name || !r->in.keyclass )
 		return WERR_INVALID_PARAM;
 
 	DEBUG(8,("_reg_enum_key: enumerating key [%s]\n", key->key->name));
 
-	err = reg_enumkey(p->mem_ctx, key, enum_index, (char **)&name->name,
-			  last_changed_time);
+	err = reg_enumkey(p->mem_ctx, key, r->in.enum_index, (char **)&r->out.name->name,
+			  r->out.last_changed_time);
 	if (!W_ERROR_IS_OK(err)) {
 		return err;
 	}
-	keyclass->name = "";
+	r->out.keyclass->name = "";
 	return WERR_OK;
 }
 
@@ -428,13 +409,10 @@ WERROR _winreg_EnumKey(pipes_struct *p, struct policy_handle *handle, uint32_t e
  Implementation of REG_ENUM_VALUE
  ****************************************************************************/
 
-WERROR _winreg_EnumValue(pipes_struct *p, struct policy_handle *handle,
-			 uint32_t enum_index, struct winreg_ValNameBuf *name,
-			 enum winreg_Type *type, uint8_t **data,
-			 uint32_t *data_size, uint32_t *value_length)
+WERROR _winreg_EnumValue(pipes_struct *p, struct winreg_EnumValue *r)
 {
 	WERROR err;
-	struct registry_key *key = find_regkey_by_hnd( p, handle );
+	struct registry_key *key = find_regkey_by_hnd( p, r->in.handle );
 	char *valname;
 	struct registry_value *val;
 	DATA_BLOB value_blob;
@@ -442,13 +420,13 @@ WERROR _winreg_EnumValue(pipes_struct *p, struct policy_handle *handle,
 	if ( !key )
 		return WERR_BADFID;
 
-	if ( !name )
+	if ( !r->in.name )
 		return WERR_INVALID_PARAM;
 
 	DEBUG(8,("_winreg_EnumValue: enumerating values for key [%s]\n",
 		 key->key->name));
 
-	err = reg_enumvalue(p->mem_ctx, key, enum_index, &valname, &val);
+	err = reg_enumvalue(p->mem_ctx, key, r->in.enum_index, &valname, &val);
 	if (!W_ERROR_IS_OK(err)) {
 		return err;
 	}
@@ -458,31 +436,31 @@ WERROR _winreg_EnumValue(pipes_struct *p, struct policy_handle *handle,
 		return err;
 	}
 
-	if (name != NULL) {
-		name->name = valname;
+	if (r->out.name != NULL) {
+		r->out.name->name = valname;
 	}
 
-	if (type != NULL) {
-		*type = val->type;
+	if (r->out.type != NULL) {
+		*r->out.type = val->type;
 	}
 
-	if (data != NULL) {
-		if ((data_size == NULL) || (value_length == NULL)) {
+	if (r->out.data != NULL) {
+		if ((r->out.data_size == NULL) || (r->out.value_length == NULL)) {
 			return WERR_INVALID_PARAM;
 		}
 
-		if (value_blob.length > *data_size) {
+		if (value_blob.length > *r->out.data_size) {
 			return WERR_MORE_DATA;
 		}
 
-		memcpy( data, value_blob.data, value_blob.length );
+		memcpy( r->out.data, value_blob.data, value_blob.length );
 	}
 
-	if (value_length != NULL) {
-		*value_length = value_blob.length;
+	if (r->out.value_length != NULL) {
+		*r->out.value_length = value_blob.length;
 	}
-	if (data_size != NULL) {
-		*data_size = value_blob.length;
+	if (r->out.data_size != NULL) {
+		*r->out.data_size = value_blob.length;
 	}
 
 	return WERR_OK;
@@ -492,15 +470,21 @@ WERROR _winreg_EnumValue(pipes_struct *p, struct policy_handle *handle,
  reg_shutdwon
  ********************************************************************/
 
-WERROR _winreg_InitiateSystemShutdown(pipes_struct *p, uint16_t *hostname, struct initshutdown_String *message, uint32_t timeout, uint8_t force_apps, uint8_t reboot)
+WERROR _winreg_InitiateSystemShutdown(pipes_struct *p, struct winreg_InitiateSystemShutdown *r)
 {
-	uint32_t reason = 0;
+	struct winreg_InitiateSystemShutdownEx s;
+
+	s.in.hostname = r->in.hostname;
+	s.in.message = r->in.message;
+	s.in.timeout = r->in.timeout;
+	s.in.force_apps = r->in.force_apps;
+	s.in.reboot = r->in.reboot;
+	s.in.reason = 0;
 
 	/* thunk down to _winreg_InitiateSystemShutdownEx() 
 	   (just returns a status) */
 	
-	return _winreg_InitiateSystemShutdownEx( p, hostname, message, timeout, 
-		force_apps, reboot, reason );
+	return _winreg_InitiateSystemShutdownEx( p, &s );
 }
 
 /*******************************************************************
@@ -511,14 +495,14 @@ WERROR _winreg_InitiateSystemShutdown(pipes_struct *p, uint16_t *hostname, struc
 #define SHUTDOWN_F_STRING "-f"
 
 
-WERROR _winreg_InitiateSystemShutdownEx(pipes_struct *p, uint16_t *hostname, struct initshutdown_String *message, uint32_t timeout, uint8_t force_apps, uint8_t reboot, uint32_t reason)
+WERROR _winreg_InitiateSystemShutdownEx(pipes_struct *p, struct winreg_InitiateSystemShutdownEx *r)
 {
 	pstring shutdown_script;
 	char *msg = NULL;
 	pstring chkmsg;
 	fstring str_timeout;
 	fstring str_reason;
-	fstring r;
+	fstring reboot;
 	fstring f;
 	int ret;
 	BOOL can_shutdown;
@@ -533,21 +517,21 @@ WERROR _winreg_InitiateSystemShutdownEx(pipes_struct *p, uint16_t *hostname, str
 
 	chkmsg[0] = '\0';
 
-	if ( message && message->name && message->name->name ) {
-		if ( (msg = talloc_strdup(p->mem_ctx, message->name->name )) == NULL ) {
+	if ( r->in.message && r->in.message->name && r->in.message->name->name ) {
+		if ( (msg = talloc_strdup(p->mem_ctx, r->in.message->name->name )) == NULL ) {
 			return WERR_NOMEM;
 		}
 		alpha_strcpy (chkmsg, msg, NULL, sizeof(chkmsg));
 	} 
 		
-	fstr_sprintf(str_timeout, "%d", timeout);
-	fstr_sprintf(r, reboot ? SHUTDOWN_R_STRING : "");
-	fstr_sprintf(f, force_apps ? SHUTDOWN_F_STRING : "");
-	fstr_sprintf(str_reason, "%d", reason );
+	fstr_sprintf(str_timeout, "%d", r->in.timeout);
+	fstr_sprintf(reboot, r->in.reboot ? SHUTDOWN_R_STRING : "");
+	fstr_sprintf(f, r->in.force_apps ? SHUTDOWN_F_STRING : "");
+	fstr_sprintf(str_reason, "%d", r->in.reason );
 
 	all_string_sub( shutdown_script, "%z", chkmsg, sizeof(shutdown_script) );
 	all_string_sub( shutdown_script, "%t", str_timeout, sizeof(shutdown_script) );
-	all_string_sub( shutdown_script, "%r", r, sizeof(shutdown_script) );
+	all_string_sub( shutdown_script, "%r", reboot, sizeof(shutdown_script) );
 	all_string_sub( shutdown_script, "%f", f, sizeof(shutdown_script) );
 	all_string_sub( shutdown_script, "%x", str_reason, sizeof(shutdown_script) );
 
@@ -582,7 +566,7 @@ WERROR _winreg_InitiateSystemShutdownEx(pipes_struct *p, uint16_t *hostname, str
  reg_abort_shutdwon
  ********************************************************************/
 
-WERROR _winreg_AbortSystemShutdown(pipes_struct *p, uint16_t *server)
+WERROR _winreg_AbortSystemShutdown(pipes_struct *p, struct winreg_AbortSystemShutdown *r)
 {
 	pstring abort_shutdown_script;
 	int ret;
@@ -767,19 +751,19 @@ static WERROR restore_registry_key ( REGISTRY_KEY *krecord, const char *fname )
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_RestoreKey(pipes_struct *p, struct policy_handle *handle, struct winreg_String *filename, uint32_t flags)
+WERROR _winreg_RestoreKey(pipes_struct *p, struct winreg_RestoreKey *r)
 {
-	struct registry_key *regkey = find_regkey_by_hnd( p, handle );
+	struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
 	pstring         fname;
 	int             snum;
 	
 	if ( !regkey )
 		return WERR_BADFID; 
 
-	if ( !filename || !filename->name )
+	if ( !r->in.filename || !r->in.filename->name )
 		return WERR_INVALID_PARAM;
 
-	pstrcpy( fname, filename->name );
+	pstrcpy( fname, r->in.filename->name );
 
 	DEBUG(8,("_winreg_RestoreKey: verifying restore of key [%s] from "
 		 "\"%s\"\n", regkey->key->name, fname));
@@ -954,19 +938,19 @@ static WERROR backup_registry_key ( REGISTRY_KEY *krecord, const char *fname )
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_SaveKey(pipes_struct *p, struct policy_handle *handle, struct winreg_String *filename, struct KeySecurityAttribute *sec_attrib)
+WERROR _winreg_SaveKey(pipes_struct *p, struct winreg_SaveKey *r)
 {
-	struct registry_key *regkey = find_regkey_by_hnd( p, handle );
+	struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
 	pstring         fname;
 	int             snum;
 	
 	if ( !regkey )
 		return WERR_BADFID; 
 
-	if ( !filename || !filename->name )
+	if ( !r->in.filename || !r->in.filename->name )
 		return WERR_INVALID_PARAM;
 
-	pstrcpy( fname, filename->name );
+	pstrcpy( fname, r->in.filename->name );
 
 	DEBUG(8,("_winreg_SaveKey: verifying backup of key [%s] to \"%s\"\n",
 		 regkey->key->name, fname));
@@ -983,7 +967,7 @@ WERROR _winreg_SaveKey(pipes_struct *p, struct policy_handle *handle, struct win
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_SaveKeyEx(pipes_struct *p)
+WERROR _winreg_SaveKeyEx(pipes_struct *p, struct winreg_SaveKeyEx *r)
 {
 	/* fill in your code here if you think this call should
 	   do anything */
@@ -995,28 +979,22 @@ WERROR _winreg_SaveKeyEx(pipes_struct *p)
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_CreateKey( pipes_struct *p, struct policy_handle *handle,
-			  struct winreg_String keyname, 
-			  struct winreg_String keyclass,
-			  uint32_t options, uint32_t access_mask, 
-			  struct winreg_SecBuf *secdesc,
-			  struct policy_handle *new_handle, 
-			  enum winreg_CreateAction *action_taken )
+WERROR _winreg_CreateKey( pipes_struct *p, struct winreg_CreateKey *r)
 {
-	struct registry_key *parent = find_regkey_by_hnd(p, handle);
+	struct registry_key *parent = find_regkey_by_hnd(p, r->in.handle);
 	struct registry_key *new_key;
 	WERROR result;
 
 	if ( !parent )
 		return WERR_BADFID;
 
-	result = reg_createkey(NULL, parent, keyname.name, access_mask,
-			       &new_key, action_taken);
+	result = reg_createkey(NULL, parent, r->in.name.name, r->in.access_mask,
+			       &new_key, r->out.action_taken);
 	if (!W_ERROR_IS_OK(result)) {
 		return result;
 	}
 
-	if (!create_policy_hnd(p, new_handle, free_regkey, new_key)) {
+	if (!create_policy_hnd(p, r->out.new_handle, free_regkey, new_key)) {
 		TALLOC_FREE(new_key);
 		return WERR_BADFILE;
 	}
@@ -1027,64 +1005,60 @@ WERROR _winreg_CreateKey( pipes_struct *p, struct policy_handle *handle,
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_SetValue(pipes_struct *p, struct policy_handle *handle,
-			struct winreg_String name, enum winreg_Type type,
-			uint8_t *data, uint32_t size)
+WERROR _winreg_SetValue(pipes_struct *p, struct winreg_SetValue *r)
 {
-	struct registry_key *key = find_regkey_by_hnd(p, handle);
+	struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
 	struct registry_value *val;
 	WERROR status;
 
 	if ( !key )
 		return WERR_BADFID;
 
-	DEBUG(8,("_reg_set_value: Setting value for [%s:%s]\n", key->key->name,
-		 name.name));
+	DEBUG(8,("_reg_set_value: Setting value for [%s:%s]\n", 
+			 key->key->name, r->in.name.name));
 
-	status = registry_pull_value(p->mem_ctx, &val, type, data, size, size);
+	status = registry_pull_value(p->mem_ctx, &val, r->in.type, r->in.data, 
+								 r->in.size, r->in.size);
 	if (!W_ERROR_IS_OK(status)) {
 		return status;
 	}
 
-	return reg_setvalue(key, name.name, val);
+	return reg_setvalue(key, r->in.name.name, val);
 }
 
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_DeleteKey(pipes_struct *p, struct policy_handle *handle,
-			 struct winreg_String key)
+WERROR _winreg_DeleteKey(pipes_struct *p, struct winreg_DeleteKey *r)
 {
-	struct registry_key *parent = find_regkey_by_hnd(p, handle);
+	struct registry_key *parent = find_regkey_by_hnd(p, r->in.handle);
 
 	if ( !parent )
 		return WERR_BADFID;
 
-	return reg_deletekey(parent, key.name);
+	return reg_deletekey(parent, r->in.key.name);
 }
 
 
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_DeleteValue(pipes_struct *p, struct policy_handle *handle,
-			   struct winreg_String value)
+WERROR _winreg_DeleteValue(pipes_struct *p, struct winreg_DeleteValue *r)
 {
-	struct registry_key *key = find_regkey_by_hnd(p, handle);
+	struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
 	
 	if ( !key )
 		return WERR_BADFID;
 
-	return reg_deletevalue(key, value.name);
+	return reg_deletevalue(key, r->in.value.name);
 }
 
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_GetKeySecurity(pipes_struct *p, struct policy_handle *handle,
-			      uint32_t sec_info, struct KeySecurityData *sd)
+WERROR _winreg_GetKeySecurity(pipes_struct *p, struct winreg_GetKeySecurity *r)
 {
-	struct registry_key *key = find_regkey_by_hnd(p, handle);
+	struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
 	WERROR err;
 	struct security_descriptor *secdesc;
 	uint8 *data;
@@ -1109,14 +1083,14 @@ WERROR _winreg_GetKeySecurity(pipes_struct *p, struct policy_handle *handle,
 		return err;
 	}
 
-	if (len > sd->size) {
-		sd->size = len;
+	if (len > r->out.sd->size) {
+		r->out.sd->size = len;
 		return WERR_INSUFFICIENT_BUFFER;
 	}
 
-	sd->size = len;
-	sd->len = len;
-	sd->data = data;
+	r->out.sd->size = len;
+	r->out.sd->len = len;
+	r->out.sd->data = data;
 		
 	return WERR_OK;
 }
@@ -1124,9 +1098,9 @@ WERROR _winreg_GetKeySecurity(pipes_struct *p, struct policy_handle *handle,
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_SetKeySecurity(pipes_struct *p, struct policy_handle *handle, uint32_t access_mask, struct KeySecurityData *sd)
+WERROR _winreg_SetKeySecurity(pipes_struct *p, struct winreg_SetKeySecurity *r)
 {
-	struct registry_key *key = find_regkey_by_hnd(p, handle);
+	struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
 	struct security_descriptor *secdesc;
 	WERROR err;
 
@@ -1138,8 +1112,8 @@ WERROR _winreg_SetKeySecurity(pipes_struct *p, struct policy_handle *handle, uin
 	if ( !(key->key->access_granted & STD_RIGHT_WRITE_DAC_ACCESS) )
 		return WERR_ACCESS_DENIED;
 
-	err = ntstatus_to_werror(unmarshall_sec_desc(p->mem_ctx, sd->data,
-						     sd->len, &secdesc));
+	err = ntstatus_to_werror(unmarshall_sec_desc(p->mem_ctx, r->in.sd->data,
+						     r->in.sd->len, &secdesc));
 	if (!W_ERROR_IS_OK(err)) {
 		return err;
 	}
@@ -1150,7 +1124,7 @@ WERROR _winreg_SetKeySecurity(pipes_struct *p, struct policy_handle *handle, uin
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_FlushKey(pipes_struct *p, struct policy_handle *handle)
+WERROR _winreg_FlushKey(pipes_struct *p, struct winreg_FlushKey *r)
 {
 	/* I'm just replying OK because there's not a lot 
 	   here I see to do i  --jerry */
@@ -1161,7 +1135,7 @@ WERROR _winreg_FlushKey(pipes_struct *p, struct policy_handle *handle)
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_UnLoadKey(pipes_struct *p)
+WERROR _winreg_UnLoadKey(pipes_struct *p, struct winreg_UnLoadKey *r)
 {
 	/* fill in your code here if you think this call should
 	   do anything */
@@ -1173,7 +1147,7 @@ WERROR _winreg_UnLoadKey(pipes_struct *p)
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_ReplaceKey(pipes_struct *p)
+WERROR _winreg_ReplaceKey(pipes_struct *p, struct winreg_ReplaceKey *r)
 {
 	/* fill in your code here if you think this call should
 	   do anything */
@@ -1185,7 +1159,7 @@ WERROR _winreg_ReplaceKey(pipes_struct *p)
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_LoadKey(pipes_struct *p, struct policy_handle *handle, struct winreg_String *keyname, struct winreg_String *filename)
+WERROR _winreg_LoadKey(pipes_struct *p, struct winreg_LoadKey *r)
 {
 	/* fill in your code here if you think this call should
 	   do anything */
@@ -1197,7 +1171,7 @@ WERROR _winreg_LoadKey(pipes_struct *p, struct policy_handle *handle, struct win
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_NotifyChangeKeyValue(pipes_struct *p, struct policy_handle *handle, uint8_t watch_subtree, uint32_t notify_filter, uint32_t unknown, struct winreg_String string1, struct winreg_String string2, uint32_t unknown2)
+WERROR _winreg_NotifyChangeKeyValue(pipes_struct *p, struct winreg_NotifyChangeKeyValue *r)
 {
 	/* fill in your code here if you think this call should
 	   do anything */
@@ -1209,7 +1183,7 @@ WERROR _winreg_NotifyChangeKeyValue(pipes_struct *p, struct policy_handle *handl
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_QueryMultipleValues(pipes_struct *p, struct policy_handle *key_handle, struct QueryMultipleValue *values, uint32_t num_values, uint8_t *buffer, uint32_t *buffer_size)
+WERROR _winreg_QueryMultipleValues(pipes_struct *p, struct winreg_QueryMultipleValues *r)
 {
 	/* fill in your code here if you think this call should
 	   do anything */
@@ -1221,7 +1195,7 @@ WERROR _winreg_QueryMultipleValues(pipes_struct *p, struct policy_handle *key_ha
 /*******************************************************************
  ********************************************************************/
 
-WERROR _winreg_QueryMultipleValues2(pipes_struct *p)
+WERROR _winreg_QueryMultipleValues2(pipes_struct *p, struct winreg_QueryMultipleValues2 *r)
 {
 	/* fill in your code here if you think this call should
 	   do anything */
diff --git a/source3/rpc_server/srv_wkssvc_nt.c b/source3/rpc_server/srv_wkssvc_nt.c
index 3ed1cbe682..1a827b265b 100644
--- a/source3/rpc_server/srv_wkssvc_nt.c
+++ b/source3/rpc_server/srv_wkssvc_nt.c
@@ -56,14 +56,13 @@ static void create_wks_info_100(struct wkssvc_NetWkstaInfo100 *info100)
  only supports info level 100 at the moment.
  ********************************************************************/
 
-WERROR _wkssvc_NetWkstaGetInfo( pipes_struct *p, const char *server_name, uint32_t level, 
-                                 union wkssvc_NetWkstaInfo *info )
+WERROR _wkssvc_NetWkstaGetInfo( pipes_struct *p, struct wkssvc_NetWkstaGetInfo *r)
 {
 	struct wkssvc_NetWkstaInfo100 *wks100 = NULL;
 	
 	/* We only support info level 100 currently */
 	
-	if ( level != 100 ) {
+	if ( r->in.level != 100 ) {
 		return WERR_UNKNOWN_LEVEL;
 	}
 
@@ -73,7 +72,7 @@ WERROR _wkssvc_NetWkstaGetInfo( pipes_struct *p, const char *server_name, uint32
 
 	create_wks_info_100( wks100 );
 	
-	info->info100 = wks100;
+	r->out.info->info100 = wks100;
 
 	return WERR_OK;
 }
@@ -81,9 +80,7 @@ WERROR _wkssvc_NetWkstaGetInfo( pipes_struct *p, const char *server_name, uint32
 /********************************************************************
  ********************************************************************/
 
-WERROR _wkssvc_NetWkstaSetInfo( pipes_struct *p, const char *server_name, 
-                                uint32_t level, union wkssvc_NetWkstaInfo *info,
-                                uint32_t *parm_error )
+WERROR _wkssvc_NetWkstaSetInfo( pipes_struct *p, struct wkssvc_NetWkstaSetInfo *r)
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -93,12 +90,7 @@ WERROR _wkssvc_NetWkstaSetInfo( pipes_struct *p, const char *server_name,
 /********************************************************************
  ********************************************************************/
 
-WERROR _wkssvc_NetWkstaEnumUsers( pipes_struct *p, const char *server_name,
-                                  uint32_t level, 
-                                  union WKS_USER_ENUM_UNION *users,
-                                  uint32_t prefmaxlen, uint32_t *entriesread,
-                                  uint32_t *totalentries, 
-                                  uint32_t *resumehandle )
+WERROR _wkssvc_NetWkstaEnumUsers( pipes_struct *p, struct wkssvc_NetWkstaEnumUsers *r)
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -108,7 +100,7 @@ WERROR _wkssvc_NetWkstaEnumUsers( pipes_struct *p, const char *server_name,
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRWKSTAUSERGETINFO( pipes_struct *p )
+WERROR _WKSSVC_NETRWKSTAUSERGETINFO( pipes_struct *p, struct WKSSVC_NETRWKSTAUSERGETINFO *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -118,7 +110,7 @@ WERROR _WKSSVC_NETRWKSTAUSERGETINFO( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRWKSTAUSERSETINFO( pipes_struct *p )
+WERROR _WKSSVC_NETRWKSTAUSERSETINFO( pipes_struct *p, struct WKSSVC_NETRWKSTAUSERSETINFO *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -128,7 +120,7 @@ WERROR _WKSSVC_NETRWKSTAUSERSETINFO( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _wkssvc_NetWkstaTransportEnum( pipes_struct *p, const char *server_name, uint32_t *level, union wkssvc_NetWkstaTransportCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _wkssvc_NetWkstaTransportEnum( pipes_struct *p, struct wkssvc_NetWkstaTransportEnum *r)
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -138,7 +130,7 @@ WERROR _wkssvc_NetWkstaTransportEnum( pipes_struct *p, const char *server_name,
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRWKSTATRANSPORTADD( pipes_struct *p )
+WERROR _WKSSVC_NETRWKSTATRANSPORTADD( pipes_struct *p, struct WKSSVC_NETRWKSTATRANSPORTADD *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -148,7 +140,7 @@ WERROR _WKSSVC_NETRWKSTATRANSPORTADD( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRWKSTATRANSPORTDEL( pipes_struct *p )
+WERROR _WKSSVC_NETRWKSTATRANSPORTDEL( pipes_struct *p, struct WKSSVC_NETRWKSTATRANSPORTDEL *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -158,7 +150,7 @@ WERROR _WKSSVC_NETRWKSTATRANSPORTDEL( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRUSEADD( pipes_struct *p )
+WERROR _WKSSVC_NETRUSEADD( pipes_struct *p, struct WKSSVC_NETRUSEADD *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -168,7 +160,7 @@ WERROR _WKSSVC_NETRUSEADD( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRUSEGETINFO( pipes_struct *p )
+WERROR _WKSSVC_NETRUSEGETINFO( pipes_struct *p, struct WKSSVC_NETRUSEGETINFO *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -178,7 +170,7 @@ WERROR _WKSSVC_NETRUSEGETINFO( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRUSEDEL( pipes_struct *p )
+WERROR _WKSSVC_NETRUSEDEL( pipes_struct *p, struct WKSSVC_NETRUSEDEL *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -188,7 +180,7 @@ WERROR _WKSSVC_NETRUSEDEL( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRUSEENUM( pipes_struct *p )
+WERROR _WKSSVC_NETRUSEENUM( pipes_struct *p, struct WKSSVC_NETRUSEENUM *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -198,7 +190,7 @@ WERROR _WKSSVC_NETRUSEENUM( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRMESSAGEBUFFERSEND( pipes_struct *p )
+WERROR _WKSSVC_NETRMESSAGEBUFFERSEND( pipes_struct *p, struct WKSSVC_NETRMESSAGEBUFFERSEND *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -208,7 +200,7 @@ WERROR _WKSSVC_NETRMESSAGEBUFFERSEND( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRWORKSTATIONSTATISTICSGET( pipes_struct *p )
+WERROR _WKSSVC_NETRWORKSTATIONSTATISTICSGET( pipes_struct *p, struct WKSSVC_NETRWORKSTATIONSTATISTICSGET *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -218,7 +210,7 @@ WERROR _WKSSVC_NETRWORKSTATIONSTATISTICSGET( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRLOGONDOMAINNAMEADD( pipes_struct *p )
+WERROR _WKSSVC_NETRLOGONDOMAINNAMEADD( pipes_struct *p, struct WKSSVC_NETRLOGONDOMAINNAMEADD *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -228,7 +220,7 @@ WERROR _WKSSVC_NETRLOGONDOMAINNAMEADD( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRLOGONDOMAINNAMEDEL( pipes_struct *p )
+WERROR _WKSSVC_NETRLOGONDOMAINNAMEDEL( pipes_struct *p, struct WKSSVC_NETRLOGONDOMAINNAMEDEL *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -238,7 +230,7 @@ WERROR _WKSSVC_NETRLOGONDOMAINNAMEDEL( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRJOINDOMAIN( pipes_struct *p )
+WERROR _WKSSVC_NETRJOINDOMAIN( pipes_struct *p, struct WKSSVC_NETRJOINDOMAIN *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -248,7 +240,7 @@ WERROR _WKSSVC_NETRJOINDOMAIN( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRUNJOINDOMAIN( pipes_struct *p )
+WERROR _WKSSVC_NETRUNJOINDOMAIN( pipes_struct *p, struct WKSSVC_NETRUNJOINDOMAIN *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -258,7 +250,7 @@ WERROR _WKSSVC_NETRUNJOINDOMAIN( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRRENAMEMACHINEINDOMAIN( pipes_struct *p )
+WERROR _WKSSVC_NETRRENAMEMACHINEINDOMAIN( pipes_struct *p, struct WKSSVC_NETRRENAMEMACHINEINDOMAIN *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -268,7 +260,7 @@ WERROR _WKSSVC_NETRRENAMEMACHINEINDOMAIN( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRVALIDATENAME( pipes_struct *p )
+WERROR _WKSSVC_NETRVALIDATENAME( pipes_struct *p, struct WKSSVC_NETRVALIDATENAME *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -278,7 +270,7 @@ WERROR _WKSSVC_NETRVALIDATENAME( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRGETJOININFORMATION( pipes_struct *p )
+WERROR _WKSSVC_NETRGETJOININFORMATION( pipes_struct *p, struct WKSSVC_NETRGETJOININFORMATION *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -288,7 +280,7 @@ WERROR _WKSSVC_NETRGETJOININFORMATION( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRGETJOINABLEOUS( pipes_struct *p )
+WERROR _WKSSVC_NETRGETJOINABLEOUS( pipes_struct *p, struct WKSSVC_NETRGETJOINABLEOUS *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -298,7 +290,7 @@ WERROR _WKSSVC_NETRGETJOINABLEOUS( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _wkssvc_NetrJoinDomain2(pipes_struct *p, const char *server_name, const char *domain_name, const char *account_name, const char *admin_account, struct wkssvc_PasswordBuffer *encrypted_password, uint32_t join_flags)
+WERROR _wkssvc_NetrJoinDomain2(pipes_struct *p, struct wkssvc_NetrJoinDomain2 *r)
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -308,7 +300,7 @@ WERROR _wkssvc_NetrJoinDomain2(pipes_struct *p, const char *server_name, const c
 /********************************************************************
  ********************************************************************/
 
-WERROR _wkssvc_NetrUnjoinDomain2(pipes_struct *p, const char *server_name, const char *account, struct wkssvc_PasswordBuffer *encrypted_password, uint32_t unjoin_flags)
+WERROR _wkssvc_NetrUnjoinDomain2(pipes_struct *p, struct wkssvc_NetrUnjoinDomain2 *r)
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -318,7 +310,7 @@ WERROR _wkssvc_NetrUnjoinDomain2(pipes_struct *p, const char *server_name, const
 /********************************************************************
  ********************************************************************/
 
-WERROR _wkssvc_NetrRenameMachineInDomain2(pipes_struct *p, const char *server_name, const char *NewMachineName, const char *Account, struct wkssvc_PasswordBuffer *EncryptedPassword, uint32_t RenameOptions)
+WERROR _wkssvc_NetrRenameMachineInDomain2(pipes_struct *p, struct wkssvc_NetrRenameMachineInDomain2 *r)
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -328,7 +320,7 @@ WERROR _wkssvc_NetrRenameMachineInDomain2(pipes_struct *p, const char *server_na
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRVALIDATENAME2( pipes_struct *p )
+WERROR _WKSSVC_NETRVALIDATENAME2( pipes_struct *p, struct WKSSVC_NETRVALIDATENAME2 *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -338,7 +330,7 @@ WERROR _WKSSVC_NETRVALIDATENAME2( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRGETJOINABLEOUS2( pipes_struct *p )
+WERROR _WKSSVC_NETRGETJOINABLEOUS2( pipes_struct *p, struct WKSSVC_NETRGETJOINABLEOUS2 *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -348,7 +340,7 @@ WERROR _WKSSVC_NETRGETJOINABLEOUS2( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _wkssvc_NetrAddAlternateComputerName(pipes_struct *p, const char *server_name, const char *NewAlternateMachineName, const char *Account, struct wkssvc_PasswordBuffer *EncryptedPassword, uint32_t Reserved)
+WERROR _wkssvc_NetrAddAlternateComputerName(pipes_struct *p, struct wkssvc_NetrAddAlternateComputerName *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -358,7 +350,7 @@ WERROR _wkssvc_NetrAddAlternateComputerName(pipes_struct *p, const char *server_
 /********************************************************************
  ********************************************************************/
 
-WERROR _wkssvc_NetrRemoveAlternateComputerName(pipes_struct *p, const char *server_name, const char *AlternateMachineNameToRemove, const char *Account, struct wkssvc_PasswordBuffer *EncryptedPassword, uint32_t Reserved)
+WERROR _wkssvc_NetrRemoveAlternateComputerName(pipes_struct *p, struct wkssvc_NetrRemoveAlternateComputerName *r)
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -368,7 +360,7 @@ WERROR _wkssvc_NetrRemoveAlternateComputerName(pipes_struct *p, const char *serv
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRSETPRIMARYCOMPUTERNAME( pipes_struct *p )
+WERROR _WKSSVC_NETRSETPRIMARYCOMPUTERNAME( pipes_struct *p, struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
@@ -378,7 +370,7 @@ WERROR _WKSSVC_NETRSETPRIMARYCOMPUTERNAME( pipes_struct *p )
 /********************************************************************
  ********************************************************************/
 
-WERROR _WKSSVC_NETRENUMERATECOMPUTERNAMES( pipes_struct *p )
+WERROR _WKSSVC_NETRENUMERATECOMPUTERNAMES( pipes_struct *p, struct WKSSVC_NETRENUMERATECOMPUTERNAMES *r )
 {
 	/* FIXME: Add implementation code here */
 	p->rng_fault_state = True;
-- 
cgit