4 files changed, 369 insertions, 799 deletions

diff --git a/source/rpc_server/srv_initshutdown_nt.c b/source/rpc_server/srv_initshutdown_nt.c
new file mode 100644
index 00000000000..a73077fe03e
--- /dev/null
+++ b/source/rpc_server/srv_initshutdown_nt.c
@@ -0,0 +1,63 @@
+/* 
+ *  Unix SMB/CIFS implementation.
+ *  RPC Pipe client / server routines
+ *  Copyright (C) Andrew Tridgell               1992-1997.
+ *  Copyright (C) Gerald Carter                 2006.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *  
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *  
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Implementation of registry functions. */
+
+#include "includes.h"
+#include "regfio.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_RPC_SRV
+
+
+/*******************************************************************
+ ********************************************************************/
+WERROR _initshutdown_Init(pipes_struct *p, uint16_t *hostname, struct initshutdown_String *message, uint32_t timeout, uint8_t force_apps, uint8_t reboot)
+{
+	uint32_t reason = 0;
+
+	/* thunk down to _winreg_InitiateSystemShutdownEx() 
+	   (just returns a status) */
+	
+	return _winreg_InitiateSystemShutdownEx( p, hostname, message, timeout, 
+		force_apps, reboot, reason );
+}
+
+/*******************************************************************
+ ********************************************************************/
+
+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)
+{
+	return _winreg_InitiateSystemShutdownEx( p, hostname, message, timeout, 
+		force_apps, reboot, reason );
+}
+
+
+
+
+/*******************************************************************
+ reg_abort_shutdwon
+ ********************************************************************/
+
+WERROR _initshutdown_Abort(pipes_struct *p, uint16_t *server)
+{
+	return _winreg_AbortSystemShutdown( p, server );
+}
diff --git a/source/rpc_server/srv_pipe.c b/source/rpc_server/srv_pipe.c
index 5abf1c293a2..b60ee37f405 100644
--- a/source/rpc_server/srv_pipe.c
+++ b/source/rpc_server/srv_pipe.c
@@ -2364,7 +2364,7 @@ void get_pipe_fns( int idx, struct api_struct **fns, int *n_fns )
 			wkssvc_get_pipe_fns( &cmds, &n_cmds );
 			break;
 		case PI_WINREG:
-			reg_get_pipe_fns( &cmds, &n_cmds );
+			winreg_get_pipe_fns( &cmds, &n_cmds );
 			break;
 		case PI_SPOOLSS:
 			spoolss_get_pipe_fns( &cmds, &n_cmds );
diff --git a/source/rpc_server/srv_reg.c b/source/rpc_server/srv_reg.c
deleted file mode 100644
index 17725240387..00000000000
--- a/source/rpc_server/srv_reg.c
+++ /dev/null
@@ -1,659 +0,0 @@
-/*
- *  Unix SMB/CIFS implementation.
- *  RPC Pipe client / server routines
- *  Copyright (C) Andrew Tridgell              1992-1997,
- *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
- *  Copyright (C) Paul Ashton                       1997,
- *  Copyright (C) Marc Jacobsen	   		    2000,
- *  Copyright (C) Jeremy Allison		    2001,
- *  Copyright (C) Gerald Carter 		    2002,
- *  Copyright (C) Jim McDonough <jmcd@us.ibm.com>   2003.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *  
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *  
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-/* This is the interface for the registry functions. */
-
-#include "includes.h"
-
-#undef DBGC_CLASS
-#define DBGC_CLASS DBGC_RPC_SRV
-
-/*******************************************************************
- api_reg_close
- ********************************************************************/
-
-static BOOL api_reg_close(pipes_struct *p)
-{
-	REG_Q_CLOSE q_u;
-	REG_R_CLOSE r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	/* grab the reg unknown 1 */
-	if(!reg_io_q_close("", &q_u, data, 0))
-		return False;
-
-	r_u.status = _reg_close(p, &q_u, &r_u);
-
-	if(!reg_io_r_close("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
- api_reg_open_khlm
- ********************************************************************/
-
-static BOOL api_reg_open_hklm(pipes_struct *p)
-{
-	REG_Q_OPEN_HIVE q_u;
-	REG_R_OPEN_HIVE r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	/* grab the reg open */
-	if(!reg_io_q_open_hive("", &q_u, data, 0))
-		return False;
-
-	r_u.status = _reg_open_hklm(p, &q_u, &r_u);
-
-	if(!reg_io_r_open_hive("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
- api_reg_open_khu
- ********************************************************************/
-
-static BOOL api_reg_open_hku(pipes_struct *p)
-{
-	REG_Q_OPEN_HIVE q_u;
-	REG_R_OPEN_HIVE r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	/* grab the reg open */
-	if(!reg_io_q_open_hive("", &q_u, data, 0))
-		return False;
-
-	r_u.status = _reg_open_hku(p, &q_u, &r_u);
-
-	if(!reg_io_r_open_hive("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
- api_reg_open_khcr
- ********************************************************************/
-
-static BOOL api_reg_open_hkcr(pipes_struct *p)
-{
-	REG_Q_OPEN_HIVE q_u;
-	REG_R_OPEN_HIVE r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	/* grab the reg open */
-	if(!reg_io_q_open_hive("", &q_u, data, 0))
-		return False;
-
-	r_u.status = _reg_open_hkcr(p, &q_u, &r_u);
-
-	if(!reg_io_r_open_hive("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-
-/*******************************************************************
- api_reg_open_entry
- ********************************************************************/
-
-static BOOL api_reg_open_entry(pipes_struct *p)
-{
-	REG_Q_OPEN_ENTRY q_u;
-	REG_R_OPEN_ENTRY r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	/* grab the reg open entry */
-	if(!reg_io_q_open_entry("", &q_u, data, 0))
-		return False;
-
-	/* construct reply. */
-	r_u.status = _reg_open_entry(p, &q_u, &r_u);
-
-	if(!reg_io_r_open_entry("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
- api_reg_query_value
- ********************************************************************/
-
-static BOOL api_reg_query_value(pipes_struct *p)
-{
-	REG_Q_QUERY_VALUE q_u;
-	REG_R_QUERY_VALUE r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	/* grab the reg unknown 0x11*/
-	if(!reg_io_q_query_value("", &q_u, data, 0))
-		return False;
-
-	r_u.status = _reg_query_value(p, &q_u, &r_u);
-
-	if(!reg_io_r_query_value("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
- api_reg_shutdown
- ********************************************************************/
-
-static BOOL api_reg_shutdown(pipes_struct *p)
-{
-	REG_Q_SHUTDOWN q_u;
-	REG_R_SHUTDOWN r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	/* grab the reg shutdown */
-	if(!reg_io_q_shutdown("", &q_u, data, 0))
-		return False;
-
-	r_u.status = _reg_shutdown(p, &q_u, &r_u);
-
-	if(!reg_io_r_shutdown("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
- api_reg_shutdown_ex
- ********************************************************************/
-
-static BOOL api_reg_shutdown_ex(pipes_struct *p)
-{
-	REG_Q_SHUTDOWN_EX q_u;
-	REG_R_SHUTDOWN_EX r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	/* grab the reg shutdown ex */
-	if(!reg_io_q_shutdown_ex("", &q_u, data, 0))
-		return False;
-
-	r_u.status = _reg_shutdown_ex(p, &q_u, &r_u);
-
-	if(!reg_io_r_shutdown_ex("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
- api_reg_abort_shutdown
- ********************************************************************/
-
-static BOOL api_reg_abort_shutdown(pipes_struct *p)
-{
-	REG_Q_ABORT_SHUTDOWN q_u;
-	REG_R_ABORT_SHUTDOWN r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	/* grab the reg shutdown */
-	if(!reg_io_q_abort_shutdown("", &q_u, data, 0))
-		return False;
-
-	r_u.status = _reg_abort_shutdown(p, &q_u, &r_u);
-
-	if(!reg_io_r_abort_shutdown("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-
-/*******************************************************************
- api_reg_query_key
- ********************************************************************/
-
-static BOOL api_reg_query_key(pipes_struct *p)
-{
-	REG_Q_QUERY_KEY q_u;
-	REG_R_QUERY_KEY r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	if(!reg_io_q_query_key("", &q_u, data, 0))
-		return False;
-
-	r_u.status = _reg_query_key(p, &q_u, &r_u);
-
-	if(!reg_io_r_query_key("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
- api_reg_getversion
- ********************************************************************/
-
-static BOOL api_reg_getversion(pipes_struct *p)
-{
-	REG_Q_GETVERSION q_u;
-	REG_R_GETVERSION r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	if(!reg_io_q_getversion("", &q_u, data, 0))
-		return False;
-
-	r_u.status = _reg_getversion(p, &q_u, &r_u);
-
-	if(!reg_io_r_getversion("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
- api_reg_enum_key
- ********************************************************************/
-
-static BOOL api_reg_enum_key(pipes_struct *p)
-{
-	REG_Q_ENUM_KEY q_u;
-	REG_R_ENUM_KEY r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	if(!reg_io_q_enum_key("", &q_u, data, 0))
-		return False;
-
-	r_u.status = _reg_enum_key(p, &q_u, &r_u);
-
-	if(!reg_io_r_enum_key("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
- api_reg_enum_value
- ********************************************************************/
-
-static BOOL api_reg_enum_value(pipes_struct *p)
-{
-	REG_Q_ENUM_VALUE q_u;
-	REG_R_ENUM_VALUE r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	if(!reg_io_q_enum_val("", &q_u, data, 0))
-		return False;
-		
-	r_u.status = _reg_enum_value(p, &q_u, &r_u);
-
-	if(!reg_io_r_enum_val("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
- ******************************************************************/
-
-static BOOL api_reg_restore_key(pipes_struct *p)
-{
-	REG_Q_RESTORE_KEY q_u;
-	REG_R_RESTORE_KEY r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	if(!reg_io_q_restore_key("", &q_u, data, 0))
-		return False;
-
-	r_u.status = _reg_restore_key(p, &q_u, &r_u);
-
-	if(!reg_io_r_restore_key("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
- ********************************************************************/
-
-static BOOL api_reg_save_key(pipes_struct *p)
-{
-	REG_Q_SAVE_KEY q_u;
-	REG_R_SAVE_KEY r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	if(!reg_io_q_save_key("", &q_u, data, 0))
-		return False;
-		
-	r_u.status = _reg_save_key(p, &q_u, &r_u);
-
-	if(!reg_io_r_save_key("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
- api_reg_open_hkpd
- ********************************************************************/
-
-static BOOL api_reg_open_hkpd(pipes_struct *p)
-{
-	REG_Q_OPEN_HIVE q_u;
-	REG_R_OPEN_HIVE r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	/* grab the reg open */
-	if(!reg_io_q_open_hive("", &q_u, data, 0))
-		return False;
-
-	r_u.status = _reg_open_hkpd(p, &q_u, &r_u);
-
-	if(!reg_io_r_open_hive("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
- api_reg_open_hkpd
- ********************************************************************/
-static BOOL api_reg_open_hkpt(pipes_struct *p)
-{
-	REG_Q_OPEN_HIVE q_u;
-	REG_R_OPEN_HIVE r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	/* grab the reg open */
-	if(!reg_io_q_open_hive("", &q_u, data, 0))
-		return False;
-
-	r_u.status = _reg_open_hkpt(p, &q_u, &r_u);
-
-	if(!reg_io_r_open_hive("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
- ******************************************************************/
-
-static BOOL api_reg_create_key_ex(pipes_struct *p)
-{
-	REG_Q_CREATE_KEY_EX q_u;
-	REG_R_CREATE_KEY_EX r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	if(!reg_io_q_create_key_ex("", &q_u, data, 0))
-		return False;
-		
-	r_u.status = _reg_create_key_ex(p, &q_u, &r_u);
-
-	if(!reg_io_r_create_key_ex("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
- ******************************************************************/
-
-static BOOL api_reg_set_value(pipes_struct *p)
-{
-	REG_Q_SET_VALUE q_u;
-	REG_R_SET_VALUE r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	if(!reg_io_q_set_value("", &q_u, data, 0))
-		return False;
-		
-	r_u.status = _reg_set_value(p, &q_u, &r_u);
-
-	if(!reg_io_r_set_value("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
- ******************************************************************/
-
-static BOOL api_reg_delete_key(pipes_struct *p)
-{
-	REG_Q_DELETE_KEY q_u;
-	REG_R_DELETE_KEY r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	if(!reg_io_q_delete_key("", &q_u, data, 0))
-		return False;
-		
-	r_u.status = _reg_delete_key(p, &q_u, &r_u);
-
-	if(!reg_io_r_delete_key("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
- ******************************************************************/
-
-static BOOL api_reg_delete_value(pipes_struct *p)
-{
-	REG_Q_DELETE_VALUE q_u;
-	REG_R_DELETE_VALUE r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	if(!reg_io_q_delete_value("", &q_u, data, 0))
-		return False;
-		
-	r_u.status = _reg_delete_value(p, &q_u, &r_u);
-
-	if(!reg_io_r_delete_value("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-
-/*******************************************************************
- ******************************************************************/
-
-static BOOL api_reg_get_key_sec(pipes_struct *p)
-{
-	REG_Q_GET_KEY_SEC q_u;
-	REG_R_GET_KEY_SEC r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	if(!reg_io_q_get_key_sec("", &q_u, data, 0))
-		return False;
-		
-	r_u.status = _reg_get_key_sec(p, &q_u, &r_u);
-
-	if(!reg_io_r_get_key_sec("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-
-/*******************************************************************
- ******************************************************************/
-
-static BOOL api_reg_set_key_sec(pipes_struct *p)
-{
-	REG_Q_SET_KEY_SEC q_u;
-	REG_R_SET_KEY_SEC r_u;
-	prs_struct *data = &p->in_data.data;
-	prs_struct *rdata = &p->out_data.rdata;
-
-	ZERO_STRUCT(q_u);
-	ZERO_STRUCT(r_u);
-
-	if(!reg_io_q_set_key_sec("", &q_u, data, 0))
-		return False;
-		
-	r_u.status = _reg_set_key_sec(p, &q_u, &r_u);
-
-	if(!reg_io_r_set_key_sec("", &r_u, rdata, 0))
-		return False;
-
-	return True;
-}
-
-
-/*******************************************************************
- array of \PIPE\reg operations
- ********************************************************************/
-
-static struct api_struct api_reg_cmds[] =
-{
-      { "REG_CLOSE"              , REG_CLOSE              , api_reg_close            },
-      { "REG_OPEN_ENTRY"         , REG_OPEN_ENTRY         , api_reg_open_entry       },
-      { "REG_OPEN_HKCR"          , REG_OPEN_HKCR          , api_reg_open_hkcr        },
-      { "REG_OPEN_HKLM"          , REG_OPEN_HKLM          , api_reg_open_hklm        },
-      { "REG_OPEN_HKPD"          , REG_OPEN_HKPD          , api_reg_open_hkpd        },
-      { "REG_OPEN_HKPT"          , REG_OPEN_HKPT          , api_reg_open_hkpt        },
-      { "REG_OPEN_HKU"           , REG_OPEN_HKU           , api_reg_open_hku         },
-      { "REG_ENUM_KEY"           , REG_ENUM_KEY           , api_reg_enum_key         },
-      { "REG_ENUM_VALUE"         , REG_ENUM_VALUE         , api_reg_enum_value       },
-      { "REG_QUERY_KEY"          , REG_QUERY_KEY          , api_reg_query_key        },
-      { "REG_QUERY_VALUE"        , REG_QUERY_VALUE        , api_reg_query_value      },
-      { "REG_SHUTDOWN"           , REG_SHUTDOWN           , api_reg_shutdown         },
-      { "REG_SHUTDOWN_EX"        , REG_SHUTDOWN_EX        , api_reg_shutdown_ex      },
-      { "REG_ABORT_SHUTDOWN"     , REG_ABORT_SHUTDOWN     , api_reg_abort_shutdown   },
-      { "REG_GETVERSION"         , REG_GETVERSION         , api_reg_getversion       },
-      { "REG_SAVE_KEY"           , REG_SAVE_KEY           , api_reg_save_key         },
-      { "REG_RESTORE_KEY"        , REG_RESTORE_KEY        , api_reg_restore_key      },
-      { "REG_CREATE_KEY_EX"      , REG_CREATE_KEY_EX      , api_reg_create_key_ex    },
-      { "REG_SET_VALUE"          , REG_SET_VALUE          , api_reg_set_value        },
-      { "REG_DELETE_KEY"         , REG_DELETE_KEY         , api_reg_delete_key       },
-      { "REG_DELETE_VALUE"       , REG_DELETE_VALUE       , api_reg_delete_value     },
-      { "REG_GET_KEY_SEC"        , REG_GET_KEY_SEC        , api_reg_get_key_sec      },
-      { "REG_SET_KEY_SEC"        , REG_SET_KEY_SEC        , api_reg_set_key_sec      }
-};
-
-void reg_get_pipe_fns( struct api_struct **fns, int *n_fns )
-{
-	*fns = api_reg_cmds;
-	*n_fns = sizeof(api_reg_cmds) / sizeof(struct api_struct);
-}
-    
-NTSTATUS rpc_reg_init(void)
-{
-
-  return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "winreg", "winreg", api_reg_cmds,
-				    sizeof(api_reg_cmds) / sizeof(struct api_struct));
-}
diff --git a/source/rpc_server/srv_reg_nt.c b/source/rpc_server/srv_winreg_nt.c
index 3728252c993..aea848fd17a 100644
--- a/source/rpc_server/srv_reg_nt.c
+++ b/source/rpc_server/srv_winreg_nt.c
@@ -2,8 +2,6 @@
  *  Unix SMB/CIFS implementation.
  *  RPC Pipe client / server routines
  *  Copyright (C) Andrew Tridgell               1992-1997.
- *  Copyright (C) Luke Kenneth Casson Leighton  1996-1997.
- *  Copyright (C) Paul Ashton                        1997.
  *  Copyright (C) Jeremy Allison                     2001.
  *  Copyright (C) Gerald Carter                      2002-2005.
  *
@@ -30,9 +28,10 @@
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_RPC_SRV
 
+#if 0	/* temporaily disabled */
 static struct generic_mapping reg_generic_map = 
 	{ REG_KEY_READ, REG_KEY_WRITE, REG_KEY_EXECUTE, REG_KEY_ALL };
-
+#endif
 
 /******************************************************************
  free() function for REGISTRY_KEY
@@ -207,11 +206,11 @@ static BOOL get_value_information( REGISTRY_KEY *key, uint32 *maxnum,
  reg_close
  ********************************************************************/
 
-WERROR _reg_close(pipes_struct *p, REG_Q_CLOSE *q_u, REG_R_CLOSE *r_u)
+WERROR _winreg_CloseKey(pipes_struct *p, struct policy_handle *handle)
 {
 	/* close the policy handle */
 
-	if (!close_registry_key(p, &q_u->pol))
+	if (!close_registry_key(p, handle))
 		return WERR_BADFID; 
 
 	return WERR_OK;
@@ -220,68 +219,110 @@ WERROR _reg_close(pipes_struct *p, REG_Q_CLOSE *q_u, REG_R_CLOSE *r_u)
 /*******************************************************************
  ********************************************************************/
 
-WERROR _reg_open_hklm(pipes_struct *p, REG_Q_OPEN_HIVE *q_u, REG_R_OPEN_HIVE *r_u)
+WERROR _winreg_OpenHKLM(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
 {
 	REGISTRY_KEY *keyinfo;
 	
-	return open_registry_key( p, &r_u->pol, &keyinfo, NULL, KEY_HKLM, q_u->access );
+	return open_registry_key( p, handle, &keyinfo, NULL, KEY_HKLM, access_mask );
 }
 
 /*******************************************************************
  ********************************************************************/
 
-WERROR _reg_open_hkpd(pipes_struct *p, REG_Q_OPEN_HIVE *q_u, REG_R_OPEN_HIVE *r_u)
+WERROR _winreg_OpenHKPD(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
 {
 	REGISTRY_KEY *keyinfo;
 	
-	return open_registry_key( p, &r_u->pol, &keyinfo, NULL, KEY_HKPD, q_u->access );
+	return open_registry_key( p, handle, &keyinfo, NULL, KEY_HKPD, access_mask );
 }
 
 /*******************************************************************
  ********************************************************************/
 
-WERROR _reg_open_hkpt(pipes_struct *p, REG_Q_OPEN_HIVE *q_u, REG_R_OPEN_HIVE *r_u)
+WERROR _winreg_OpenHKPT(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
 {
 	REGISTRY_KEY *keyinfo;
 	
-	return open_registry_key( p, &r_u->pol, &keyinfo, NULL, KEY_HKPT, q_u->access );
+	return open_registry_key( p, handle, &keyinfo, NULL, KEY_HKPT, access_mask );
 }
 
 /*******************************************************************
  ********************************************************************/
 
-WERROR _reg_open_hkcr(pipes_struct *p, REG_Q_OPEN_HIVE *q_u, REG_R_OPEN_HIVE *r_u)
+WERROR _winreg_OpenHKCR(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
 {
 	REGISTRY_KEY *keyinfo;
 	
-	return open_registry_key( p, &r_u->pol, &keyinfo, NULL, KEY_HKCR, q_u->access );
+	return open_registry_key( p, handle, &keyinfo, NULL, KEY_HKCR, access_mask );
 }
 
 /*******************************************************************
  ********************************************************************/
 
-WERROR _reg_open_hku(pipes_struct *p, REG_Q_OPEN_HIVE *q_u, REG_R_OPEN_HIVE *r_u)
+WERROR _winreg_OpenHKU(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
 {
 	REGISTRY_KEY *keyinfo;
-	
-	return open_registry_key( p, &r_u->pol, &keyinfo, NULL, KEY_HKU, q_u->access );
+
+	return open_registry_key( p, handle, &keyinfo, NULL, KEY_HKU, access_mask );
+}
+
+/*******************************************************************
+ ********************************************************************/
+
+WERROR _winreg_OpenHKCU(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
+{
+	REGISTRY_KEY *keyinfo;
+
+	return open_registry_key( p, handle, &keyinfo, NULL, KEY_HKCU, access_mask );
+}
+
+/*******************************************************************
+ ********************************************************************/
+
+WERROR _winreg_OpenHKCC(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
+{
+	REGISTRY_KEY *keyinfo;
+
+	return open_registry_key( p, handle, &keyinfo, NULL, KEY_HKCC, access_mask );
+}
+
+/*******************************************************************
+ ********************************************************************/
+
+WERROR _winreg_OpenHKDD(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
+{
+	REGISTRY_KEY *keyinfo;
+
+	return open_registry_key( p, handle, &keyinfo, NULL, KEY_HKDD, access_mask );
+}
+
+/*******************************************************************
+ ********************************************************************/
+
+WERROR _winreg_OpenHKPN(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
+{
+	REGISTRY_KEY *keyinfo;
+
+	return open_registry_key( p, handle, &keyinfo, NULL, KEY_HKPN, access_mask );
 }
 
 /*******************************************************************
  reg_reply_open_entry
  ********************************************************************/
 
-WERROR _reg_open_entry(pipes_struct *p, REG_Q_OPEN_ENTRY *q_u, REG_R_OPEN_ENTRY *r_u)
+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)
 {
-	fstring name;
-	REGISTRY_KEY *parent = find_regkey_index_by_hnd(p, &q_u->pol);
+	char *name;
+	REGISTRY_KEY *parent = find_regkey_index_by_hnd(p, parent_handle );
 	REGISTRY_KEY *newkey = NULL;
 	uint32 check_rights;
 
 	if ( !parent )
 		return WERR_BADFID;
 
-	rpcstr_pull( name, q_u->name.string->buffer, sizeof(name), q_u->name.string->uni_str_len*2, 0 );
+	if ( (name = talloc_strdup( p->mem_ctx, keyname.name )) == NULL ) {
+		return WERR_INVALID_PARAM;
+	}
 	
 	/* check granted access first; what is the correct mask here? */
 
@@ -302,29 +343,34 @@ WERROR _reg_open_entry(pipes_struct *p, REG_Q_OPEN_ENTRY *q_u, REG_R_OPEN_ENTRY
 	 * not do this stupidity.   --jerry
 	 */
 	 
-	return open_registry_key( p, &r_u->handle, &newkey, parent, name, q_u->access );
+	return open_registry_key( p, handle, &newkey, parent, name, access_mask );
 }
 
 /*******************************************************************
  reg_reply_info
  ********************************************************************/
 
-WERROR _reg_query_value(pipes_struct *p, REG_Q_QUERY_VALUE *q_u, REG_R_QUERY_VALUE *r_u)
+WERROR _winreg_QueryValue(pipes_struct *p, struct policy_handle *handle, struct winreg_String value_name, enum winreg_Type *type, uint8_t **data, uint32_t *size, uint32_t *length)
 {
 	WERROR			status = WERR_BADFILE;
-	fstring 		name;
-	REGISTRY_KEY 		*regkey = find_regkey_index_by_hnd( p, &q_u->pol );
+	char 			*name;
+	REGISTRY_KEY 		*regkey = find_regkey_index_by_hnd( p, handle );
 	REGISTRY_VALUE		*val = NULL;
 	REGVAL_CTR		*regvals;
 	int			i;
 
 	if ( !regkey )
 		return WERR_BADFID;
+
+	*size = *length = *type = 0;
+	value_name.name = NULL;
 		
 	DEBUG(7,("_reg_info: policy key name = [%s]\n", regkey->name));
 	DEBUG(7,("_reg_info: policy key type = [%08x]\n", regkey->type));
 	
-	rpcstr_pull(name, q_u->name.string->buffer, sizeof(name), q_u->name.string->uni_str_len*2, 0);
+	if ( (name = talloc_strdup( p->mem_ctx, value_name.name )) == NULL ) {
+		return WERR_NOMEM;
+	}
 
 	DEBUG(5,("_reg_info: looking up value: [%s]\n", name));
 
@@ -338,8 +384,8 @@ WERROR _reg_query_value(pipes_struct *p, REG_Q_QUERY_VALUE *q_u, REG_R_QUERY_VAL
 		{
 			uint32 outbuf_len;
 			prs_struct prs_hkpd;
-			prs_init(&prs_hkpd, q_u->bufsize, p->mem_ctx, MARSHALL);
-			status = reg_perfcount_get_hkpd(&prs_hkpd, q_u->bufsize, &outbuf_len, NULL);
+			prs_init(&prs_hkpd, *size, p->mem_ctx, MARSHALL);
+			status = reg_perfcount_get_hkpd(&prs_hkpd, *size, &outbuf_len, NULL);
 			regval_ctr_addvalue(regvals, "HKPD", REG_BINARY,
 					    prs_hkpd.data_p, outbuf_len);
 			val = dup_registry_value(regval_ctr_specific_value(regvals, 0));
@@ -390,8 +436,8 @@ WERROR _reg_query_value(pipes_struct *p, REG_Q_QUERY_VALUE *q_u, REG_R_QUERY_VAL
 			/* we probably have a request for a specific object here */
 			uint32 outbuf_len;
 			prs_struct prs_hkpd;
-			prs_init(&prs_hkpd, q_u->bufsize, p->mem_ctx, MARSHALL);
-			status = reg_perfcount_get_hkpd(&prs_hkpd, q_u->bufsize, &outbuf_len, name);
+			prs_init(&prs_hkpd, *size, p->mem_ctx, MARSHALL);
+			status = reg_perfcount_get_hkpd(&prs_hkpd, *size, &outbuf_len, name);
 			regval_ctr_addvalue(regvals, "HKPD", REG_BINARY,
 					    prs_hkpd.data_p, outbuf_len);
 			
@@ -420,8 +466,17 @@ WERROR _reg_query_value(pipes_struct *p, REG_Q_QUERY_VALUE *q_u, REG_R_QUERY_VAL
 	    }
 	}
 
-	init_reg_r_query_value(q_u->ptr_buf, r_u, val, status);
-	
+	if ( val ) {
+        	*size   =  regval_size( val );
+        	*length =  regval_size( val );
+
+		if ( (*data = talloc_memdup( p->mem_ctx, regval_data_p(val), *size )) == NULL ) {
+			status = WERR_NOMEM;
+		}
+
+		*type = val->type;
+	}
+
 	TALLOC_FREE( regvals );
 	free_registry_value( val );
 
@@ -431,32 +486,37 @@ WERROR _reg_query_value(pipes_struct *p, REG_Q_QUERY_VALUE *q_u, REG_R_QUERY_VAL
 /*****************************************************************************
  Implementation of REG_QUERY_KEY
  ****************************************************************************/
- 
-WERROR _reg_query_key(pipes_struct *p, REG_Q_QUERY_KEY *q_u, REG_R_QUERY_KEY *r_u)
+
+WERROR _winreg_QueryInfoKey(pipes_struct *p, struct policy_handle *handle, 
+			    struct winreg_String class_in, 
+			    struct winreg_String *class_out, 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 	status = WERR_OK;
-	REGISTRY_KEY	*regkey = find_regkey_index_by_hnd( p, &q_u->pol );
+	REGISTRY_KEY	*regkey = find_regkey_index_by_hnd( p, handle );
 	
 	if ( !regkey )
 		return WERR_BADFID; 
 	
-	if ( !get_subkey_information( regkey, &r_u->num_subkeys, &r_u->max_subkeylen ) ) {
+	if ( !get_subkey_information( regkey, num_subkeys, max_subkeylen) ) {
 		DEBUG(0,("_reg_query_key: get_subkey_information() failed!\n"));
 		return WERR_ACCESS_DENIED;
 	}
 		
-	if ( !get_value_information( regkey, &r_u->num_values, &r_u->max_valnamelen, &r_u->max_valbufsize ) ) {
+	if ( !get_value_information( regkey, num_values, max_valnamelen, max_valbufsize) ) {
 		DEBUG(0,("_reg_query_key: get_value_information() failed!\n"));
 		return WERR_ACCESS_DENIED;	
 	}
 
-		
-	r_u->sec_desc = 0x00000078;	/* size for key's sec_desc */
+	*secdescsize = 0x00000078;	/* size for key's sec_desc */
 	
 	/* Win9x set this to 0x0 since it does not keep timestamps.
 	   Doing the same here for simplicity   --jerry */
 	   
-	ZERO_STRUCT(r_u->mod_time);	
+	*last_changed_time = 0;
 
 	return status;
 }
@@ -466,17 +526,16 @@ WERROR _reg_query_key(pipes_struct *p, REG_Q_QUERY_KEY *q_u, REG_R_QUERY_KEY *r_
  Implementation of REG_GETVERSION
  ****************************************************************************/
  
-WERROR _reg_getversion(pipes_struct *p, REG_Q_GETVERSION *q_u, REG_R_GETVERSION *r_u)
+WERROR _winreg_GetVersion(pipes_struct *p, struct policy_handle *handle, uint32_t *version)
 {
-	WERROR 	status = WERR_OK;
-	REGISTRY_KEY	*regkey = find_regkey_index_by_hnd( p, &q_u->pol );
+	REGISTRY_KEY	*regkey = find_regkey_index_by_hnd( p, handle );
 	
 	if ( !regkey )
 		return WERR_BADFID;
 	
-	r_u->win_version = 0x00000005;	/* Windows 2000 registry API version */
+	*version = 0x00000005;	/* Windows 2000 registry API version */
 	
-	return status;
+	return WERR_OK;
 }
 
 
@@ -484,30 +543,34 @@ WERROR _reg_getversion(pipes_struct *p, REG_Q_GETVERSION *q_u, REG_R_GETVERSION
  Implementation of REG_ENUM_KEY
  ****************************************************************************/
  
-WERROR _reg_enum_key(pipes_struct *p, REG_Q_ENUM_KEY *q_u, REG_R_ENUM_KEY *r_u)
+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 	status = WERR_OK;
-	REGISTRY_KEY	*regkey = find_regkey_index_by_hnd( p, &q_u->pol );
+	REGISTRY_KEY	*regkey = find_regkey_index_by_hnd( p, handle );
 	char		*subkey = NULL;
 	
 	
 	if ( !regkey )
 		return WERR_BADFID; 
 
+	if ( !name || !keyclass || !last_changed_time )
+		return WERR_INVALID_PARAM;
+
 	DEBUG(8,("_reg_enum_key: enumerating key [%s]\n", regkey->name));
 	
-	if ( !fetch_reg_keys_specific( regkey, &subkey, q_u->key_index ) )
-	{
+	if ( !fetch_reg_keys_specific( regkey, &subkey, enum_index ) ) {
 		status = WERR_NO_MORE_ITEMS;
 		goto done;
 	}
 	
 	DEBUG(10,("_reg_enum_key: retrieved subkey named [%s]\n", subkey));
 	
-	/* subkey has the string name now */
-	
-	init_reg_r_enum_key( r_u, subkey );
-	
+	*last_changed_time = 0;
+	keyclass->name = NULL;
+	if ( (name->name = talloc_strdup( p->mem_ctx, subkey )) == NULL ) {
+		status = WERR_NOMEM;
+	}
+
 done:	
 	SAFE_FREE( subkey );
 	return status;
@@ -516,45 +579,42 @@ done:
 /*****************************************************************************
  Implementation of REG_ENUM_VALUE
  ****************************************************************************/
- 
-WERROR _reg_enum_value(pipes_struct *p, REG_Q_ENUM_VALUE *q_u, REG_R_ENUM_VALUE *r_u)
+
+WERROR _winreg_EnumValue(pipes_struct *p, struct policy_handle *handle, uint32_t enum_index, struct winreg_StringBuf *name, enum winreg_Type *type, uint8_t *value, uint32_t *size, uint32_t *length)
 {
 	WERROR 	status = WERR_OK;
-	REGISTRY_KEY	*regkey = find_regkey_index_by_hnd( p, &q_u->pol );
+	REGISTRY_KEY	*regkey = find_regkey_index_by_hnd( p, handle );
 	REGISTRY_VALUE	*val;
 	
-	
 	if ( !regkey )
 		return WERR_BADFID; 
 
+	if ( !name || !type || !value || !size || !length )
+		return WERR_INVALID_PARAM;
+
 	DEBUG(8,("_reg_enum_value: enumerating values for key [%s]\n", regkey->name));
 
-	if ( !fetch_reg_values_specific( regkey, &val, q_u->val_index ) ) {
+	if ( !fetch_reg_values_specific( regkey, &val, enum_index ) ) {
 		status = WERR_NO_MORE_ITEMS;
 		goto done;
 	}
 
-#if 0	/* JERRY TEST CODE */
-	if ( val->type == REG_MULTI_SZ ) {
-		char **str;
-		int num_strings = regval_convert_multi_sz( (uint16*)regval_data_p(val), regval_size(val), &str );
-		uint16 *buffer;
-		size_t buf_size;
-		
-		
-		if ( num_strings )
-			buf_size = regval_build_multi_sz( str, &buffer );
-		
-		TALLOC_FREE( str );
-		TALLOC_FREE( buffer );
-	}
-#endif
-	
 	DEBUG(10,("_reg_enum_value: retrieved value named  [%s]\n", val->valuename));
 	
 	/* subkey has the string name now */
 	
-	init_reg_r_enum_val( r_u, val );
+	if ( (name->name = talloc_strdup( p->mem_ctx, val->valuename )) == NULL ) {
+		status = WERR_NOMEM;
+	}
+
+        *size   =  regval_size( val );
+        *length =  regval_size( val );
+
+	if ( (value = talloc_memdup( p->mem_ctx, regval_data_p(val), *size )) == NULL ) {
+		status = WERR_NOMEM;
+	}
+
+	*type = val->type;
 
 done:	
 	free_registry_value( val );
@@ -567,23 +627,15 @@ done:
  reg_shutdwon
  ********************************************************************/
 
-WERROR _reg_shutdown(pipes_struct *p, REG_Q_SHUTDOWN *q_u, REG_R_SHUTDOWN *r_u)
+WERROR _winreg_InitiateSystemShutdown(pipes_struct *p, uint16_t *hostname, struct initshutdown_String *message, uint32_t timeout, uint8_t force_apps, uint8_t reboot)
 {
-	REG_Q_SHUTDOWN_EX q_u_ex;
-	REG_R_SHUTDOWN_EX r_u_ex;
-	
-	/* copy fields (including stealing memory) */
-	
-	q_u_ex.server  = q_u->server;
-	q_u_ex.message = q_u->message;
-	q_u_ex.timeout = q_u->timeout;
-	q_u_ex.force   = q_u->force;
-	q_u_ex.reboot  = q_u->reboot;
-	q_u_ex.reason  = 0x0; 	/* don't care for now */
-	
-	/* thunk down to _reg_shutdown_ex() (just returns a status) */
+	uint32_t reason = 0;
+
+	/* thunk down to _winreg_InitiateSystemShutdownEx() 
+	   (just returns a status) */
 	
-	return _reg_shutdown_ex( p, &q_u_ex, &r_u_ex );
+	return _winreg_InitiateSystemShutdownEx( p, hostname, message, timeout, 
+		force_apps, reboot, reason );
 }
 
 /*******************************************************************
@@ -594,13 +646,13 @@ WERROR _reg_shutdown(pipes_struct *p, REG_Q_SHUTDOWN *q_u, REG_R_SHUTDOWN *r_u)
 #define SHUTDOWN_F_STRING "-f"
 
 
-WERROR _reg_shutdown_ex(pipes_struct *p, REG_Q_SHUTDOWN_EX *q_u, REG_R_SHUTDOWN_EX *r_u)
+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)
 {
 	pstring shutdown_script;
-	pstring message;
+	char *msg = NULL;
 	pstring chkmsg;
-	fstring timeout;
-	fstring reason;
+	fstring str_timeout;
+	fstring str_reason;
 	fstring r;
 	fstring f;
 	int ret;
@@ -614,24 +666,23 @@ WERROR _reg_shutdown_ex(pipes_struct *p, REG_Q_SHUTDOWN_EX *q_u, REG_R_SHUTDOWN_
 
 	/* pull the message string and perform necessary sanity checks on it */
 
-	pstrcpy( message, "" );
-	if ( q_u->message ) {
-		UNISTR2 *msg_string = q_u->message->string;
-		
-		rpcstr_pull( message, msg_string->buffer, sizeof(message), msg_string->uni_str_len*2, 0 );
-	}
-	alpha_strcpy (chkmsg, message, NULL, sizeof(message));
+	if ( message && message->name && message->name->name ) {
+		if ( (msg = talloc_strdup(p->mem_ctx, message->name->name )) == NULL ) {
+			return WERR_NOMEM;
+		}
+	} 
+	alpha_strcpy (chkmsg, msg?msg:"", NULL, strlen(msg));
 		
-	fstr_sprintf(timeout, "%d", q_u->timeout);
-	fstr_sprintf(r, (q_u->reboot) ? SHUTDOWN_R_STRING : "");
-	fstr_sprintf(f, (q_u->force) ? SHUTDOWN_F_STRING : "");
-	fstr_sprintf( reason, "%d", q_u->reason );
+	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 );
 
 	all_string_sub( shutdown_script, "%z", chkmsg, sizeof(shutdown_script) );
-	all_string_sub( shutdown_script, "%t", timeout, 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, "%f", f, sizeof(shutdown_script) );
-	all_string_sub( shutdown_script, "%x", reason, sizeof(shutdown_script) );
+	all_string_sub( shutdown_script, "%x", str_reason, sizeof(shutdown_script) );
 
 	can_shutdown = user_has_privileges( p->pipe_user.nt_user_token, &se_remote_shutdown );
 		
@@ -664,7 +715,7 @@ WERROR _reg_shutdown_ex(pipes_struct *p, REG_Q_SHUTDOWN_EX *q_u, REG_R_SHUTDOWN_
  reg_abort_shutdwon
  ********************************************************************/
 
-WERROR _reg_abort_shutdown(pipes_struct *p, REG_Q_ABORT_SHUTDOWN *q_u, REG_R_ABORT_SHUTDOWN *r_u)
+WERROR _winreg_AbortSystemShutdown(pipes_struct *p, uint16_t *server)
 {
 	pstring abort_shutdown_script;
 	int ret;
@@ -696,6 +747,9 @@ WERROR _reg_abort_shutdown(pipes_struct *p, REG_Q_ABORT_SHUTDOWN *q_u, REG_R_ABO
 	return (ret == 0) ? WERR_OK : WERR_ACCESS_DENIED;
 }
 
+#if 0	/* This code works but is disabled for now until I 
+	   fix the WinReg IDL file -- jerry */
+
 /*******************************************************************
  ********************************************************************/
 
@@ -824,7 +878,7 @@ static WERROR restore_registry_key ( REGISTRY_KEY *krecord, const char *fname )
 	/* open the registry file....fail if the file already exists */
 	
 	if ( !(regfile = regfio_open( fname, (O_RDONLY), 0 )) ) {
-                DEBUG(0,("backup_registry_key: failed to open \"%s\" (%s)\n", 
+                DEBUG(0,("restore_registry_key: failed to open \"%s\" (%s)\n", 
 			fname, strerror(errno) ));
 		return ( ntstatus_to_werror(map_nt_error_from_unix( errno )) );
         }
@@ -846,11 +900,14 @@ static WERROR restore_registry_key ( REGISTRY_KEY *krecord, const char *fname )
 	return result;
 }
 
+#endif
+
 /*******************************************************************
  ********************************************************************/
 
-WERROR _reg_restore_key(pipes_struct *p, REG_Q_RESTORE_KEY  *q_u, REG_R_RESTORE_KEY *r_u)
+WERROR _winreg_RestoreKey(pipes_struct *p)
 {
+#if 0	/* temporarily disabled */
 	REGISTRY_KEY	*regkey = find_regkey_index_by_hnd( p, &q_u->pol );
 	pstring         filename;
 	int             snum;
@@ -873,8 +930,14 @@ WERROR _reg_restore_key(pipes_struct *p, REG_Q_RESTORE_KEY  *q_u, REG_R_RESTORE_
 	DEBUG(2,("_reg_restore_key: Restoring [%s] from %s in share %s\n", regkey->name, filename, lp_servicename(snum) ));
 
 	return restore_registry_key( regkey, filename );
+#endif
+
+	return WERR_NOT_SUPPORTED;
 }
 
+#if 0	/* this code works but has been disable until I fix
+	   the winreg IDL    -- jerry */
+
 /********************************************************************
 ********************************************************************/
 
@@ -1024,12 +1087,14 @@ static WERROR backup_registry_key ( REGISTRY_KEY *krecord, const char *fname )
 	
 	return result;
 }
+#endif
 
 /*******************************************************************
  ********************************************************************/
 
-WERROR _reg_save_key(pipes_struct *p, REG_Q_SAVE_KEY  *q_u, REG_R_SAVE_KEY *r_u)
+WERROR _winreg_SaveKey(pipes_struct *p)
 {
+#if 0
 	REGISTRY_KEY	*regkey = find_regkey_index_by_hnd( p, &q_u->pol );
 	pstring         filename;
 	int             snum;
@@ -1047,25 +1112,43 @@ WERROR _reg_save_key(pipes_struct *p, REG_Q_SAVE_KEY  *q_u, REG_R_SAVE_KEY *r_u)
 	DEBUG(2,("_reg_save_key: Saving [%s] to %s in share %s\n", regkey->name, filename, lp_servicename(snum) ));
 		
 	return backup_registry_key( regkey, filename );
+#endif
+
+	/* disabled for now until I fix the IDL  --jerry */
+	return WERR_NOT_SUPPORTED;
+}
+
+/*******************************************************************
+ ********************************************************************/
+
+WERROR _winreg_SaveKeyEx(pipes_struct *p)
+{
+	/* disabled for now until I fix the IDL  --jerry */
+	return WERR_NOT_SUPPORTED;
 }
 
 /*******************************************************************
  ********************************************************************/
 
-WERROR _reg_create_key_ex(pipes_struct *p, REG_Q_CREATE_KEY_EX *q_u, REG_R_CREATE_KEY_EX *r_u)
+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 )
 {
-	REGISTRY_KEY *parent = find_regkey_index_by_hnd(p, &q_u->handle);
+	REGISTRY_KEY *parent = find_regkey_index_by_hnd(p, handle);
 	REGISTRY_KEY *newparentinfo, *keyinfo;
 	POLICY_HND newparent_handle;
 	REGSUBKEY_CTR *subkeys;
 	BOOL write_result;
-	pstring name;
+	char *name;
 	WERROR result;
 
 	if ( !parent )
 		return WERR_BADFID;
-		
-	rpcstr_pull( name, q_u->name.string->buffer, sizeof(name), q_u->name.string->uni_str_len*2, 0 );
+
+	if ( (name = talloc_strdup( p->mem_ctx, keyname.name )) == NULL ) {
+		return WERR_NOMEM;
+	}
 	
 	/* ok.  Here's what we do.  */
 
@@ -1097,7 +1180,7 @@ WERROR _reg_create_key_ex(pipes_struct *p, REG_Q_CREATE_KEY_EX *q_u, REG_R_CREAT
 	else {
 		/* use the existing open key information */
 		newparentinfo = parent;
-		memcpy( &newparent_handle, &q_u->handle, sizeof(POLICY_HND) );
+		memcpy( &newparent_handle, handle, sizeof(POLICY_HND) );
 	}
 	
 	/* (3) check for create subkey rights on the correct parent */
@@ -1129,8 +1212,12 @@ WERROR _reg_create_key_ex(pipes_struct *p, REG_Q_CREATE_KEY_EX *q_u, REG_R_CREAT
 	/* (5) open the new key and return the handle.  Note that it is probably 
 	   not correct to grant full access on this open handle. */
 	
-	result = open_registry_key( p, &r_u->handle, &keyinfo, newparentinfo, name, REG_KEY_READ );
+	result = open_registry_key( p, new_handle, &keyinfo, newparentinfo, name, REG_KEY_READ );
 	keyinfo->access_granted = REG_KEY_ALL;
+	
+	/* FIXME: report the truth here */
+	
+	*action_taken = REG_CREATED_NEW_KEY;
 
 done:
 	/* close any intermediate key handles */
@@ -1145,12 +1232,12 @@ done:
 /*******************************************************************
  ********************************************************************/
 
-WERROR _reg_set_value(pipes_struct *p, REG_Q_SET_VALUE  *q_u, REG_R_SET_VALUE *r_u)
+WERROR _winreg_SetValue(pipes_struct *p, struct policy_handle *handle, struct winreg_String name, enum winreg_Type type, uint8_t *data, uint32_t size)
 {
-	REGISTRY_KEY *key = find_regkey_index_by_hnd(p, &q_u->handle);
+	REGISTRY_KEY *key = find_regkey_index_by_hnd(p, handle);
 	REGVAL_CTR *values;
 	BOOL write_result;
-	fstring valuename;
+	char *valuename;
 
 	if ( !key )
 		return WERR_BADFID;
@@ -1160,12 +1247,11 @@ WERROR _reg_set_value(pipes_struct *p, REG_Q_SET_VALUE  *q_u, REG_R_SET_VALUE *r
 	if ( !(key->access_granted & SEC_RIGHTS_SET_VALUE) )
 		return WERR_ACCESS_DENIED;
 		
-	rpcstr_pull( valuename, q_u->name.string->buffer, sizeof(valuename), q_u->name.string->uni_str_len*2, 0 );
-
 	/* verify the name */
-
-	if ( !*valuename )
+	
+	if ( (valuename = talloc_strdup(p->mem_ctx, name.name)) == NULL ) {
 		return WERR_INVALID_PARAM;
+	}
 
 	DEBUG(8,("_reg_set_value: Setting value for [%s:%s]\n", key->name, valuename));
 		
@@ -1176,7 +1262,7 @@ WERROR _reg_set_value(pipes_struct *p, REG_Q_SET_VALUE  *q_u, REG_R_SET_VALUE *r
 	
 	fetch_reg_values( key, values );
 	
-	regval_ctr_addvalue( values, valuename, q_u->type, (char*)q_u->value.buffer, q_u->value.buf_len );
+	regval_ctr_addvalue( values, valuename, type, (const char *)data, size );
 	
 	/* now write to the registry backend */
 	
@@ -1193,14 +1279,14 @@ WERROR _reg_set_value(pipes_struct *p, REG_Q_SET_VALUE  *q_u, REG_R_SET_VALUE *r
 /*******************************************************************
  ********************************************************************/
 
-WERROR _reg_delete_key(pipes_struct *p, REG_Q_DELETE_KEY  *q_u, REG_R_DELETE_KEY *r_u)
+WERROR _winreg_DeleteKey(pipes_struct *p, struct policy_handle *handle, struct winreg_String key)
 {
-	REGISTRY_KEY *parent = find_regkey_index_by_hnd(p, &q_u->handle);
+	REGISTRY_KEY *parent = find_regkey_index_by_hnd(p, handle);
 	REGISTRY_KEY *newparentinfo = NULL;
 	POLICY_HND newparent_handle;
 	REGSUBKEY_CTR *subkeys;
 	BOOL write_result;
-	pstring name;
+	char *name;
 	WERROR result;
 
 	if ( !parent )
@@ -1215,7 +1301,10 @@ WERROR _reg_delete_key(pipes_struct *p, REG_Q_DELETE_KEY  *q_u, REG_R_DELETE_KEY
 		goto done;
 	}
 		
-	rpcstr_pull( name, q_u->name.string->buffer, sizeof(name), q_u->name.string->uni_str_len*2, 0 );
+	if ( (name = talloc_strdup( p->mem_ctx, key.name )) == NULL ) {
+		result = WERR_INVALID_PARAM;
+		goto done;
+	}
 		
 	/* ok.  Here's what we do.  */
 
@@ -1272,12 +1361,12 @@ done:
 /*******************************************************************
  ********************************************************************/
 
-WERROR _reg_delete_value(pipes_struct *p, REG_Q_DELETE_VALUE  *q_u, REG_R_DELETE_VALUE *r_u)
+WERROR _winreg_DeleteValue(pipes_struct *p, struct policy_handle *handle, struct winreg_String value)
 {
-	REGISTRY_KEY *key = find_regkey_index_by_hnd(p, &q_u->handle);
+	REGISTRY_KEY *key = find_regkey_index_by_hnd(p, handle);
 	REGVAL_CTR *values;
 	BOOL write_result;
-	fstring valuename;
+	char *valuename;
 	
 	if ( !key )
 		return WERR_BADFID;
@@ -1287,10 +1376,9 @@ WERROR _reg_delete_value(pipes_struct *p, REG_Q_DELETE_VALUE  *q_u, REG_R_DELETE
 	if ( !(key->access_granted & SEC_RIGHTS_SET_VALUE) )
 		return WERR_ACCESS_DENIED;
 
-	rpcstr_pull( valuename, q_u->name.string->buffer, sizeof(valuename), q_u->name.string->uni_str_len*2, 0 );
-
-	if ( !*valuename )
+	if ( (valuename = talloc_strdup( p->mem_ctx, value.name )) == NULL ) {
 		return WERR_INVALID_PARAM;
+	}
 
 	DEBUG(8,("_reg_delete_value: Setting value for [%s:%s]\n", key->name, valuename));
 
@@ -1318,9 +1406,9 @@ WERROR _reg_delete_value(pipes_struct *p, REG_Q_DELETE_VALUE  *q_u, REG_R_DELETE
 /*******************************************************************
  ********************************************************************/
 
-WERROR _reg_get_key_sec(pipes_struct *p, REG_Q_GET_KEY_SEC  *q_u, REG_R_GET_KEY_SEC *r_u)
+WERROR _winreg_GetKeySecurity(pipes_struct *p, struct policy_handle *handle, uint32_t sec_info, struct KeySecurityData *sd)
 {
-	REGISTRY_KEY *key = find_regkey_index_by_hnd(p, &q_u->handle);
+	REGISTRY_KEY *key = find_regkey_index_by_hnd(p, handle);
 
 	if ( !key )
 		return WERR_BADFID;
@@ -1336,9 +1424,9 @@ WERROR _reg_get_key_sec(pipes_struct *p, REG_Q_GET_KEY_SEC  *q_u, REG_R_GET_KEY_
 /*******************************************************************
  ********************************************************************/
 
-WERROR _reg_set_key_sec(pipes_struct *p, REG_Q_SET_KEY_SEC  *q_u, REG_R_SET_KEY_SEC *r_u)
+WERROR _winreg_SetKeySecurity(pipes_struct *p, struct policy_handle *handle, uint32_t access_mask, struct KeySecurityData *sd)
 {
-	REGISTRY_KEY *key = find_regkey_index_by_hnd(p, &q_u->handle);
+	REGISTRY_KEY *key = find_regkey_index_by_hnd(p, handle);
 
 	if ( !key )
 		return WERR_BADFID;
@@ -1350,3 +1438,81 @@ WERROR _reg_set_key_sec(pipes_struct *p, REG_Q_SET_KEY_SEC  *q_u, REG_R_SET_KEY_
 		
 	return WERR_ACCESS_DENIED;
 }
+
+/*******************************************************************
+ ********************************************************************/
+
+WERROR _winreg_FlushKey(pipes_struct *p, struct policy_handle *handle)
+{
+	/* I'm just replying OK because there's not a lot 
+	   here I see to do i  --jerry */
+	
+	return WERR_OK;
+}
+
+/*******************************************************************
+ ********************************************************************/
+
+WERROR _winreg_UnLoadKey(pipes_struct *p)
+{
+	/* fill in your code here if you think this call should
+	   do anything */
+
+	return WERR_NOT_SUPPORTED;
+}
+
+/*******************************************************************
+ ********************************************************************/
+
+WERROR _winreg_ReplaceKey(pipes_struct *p)
+{
+	/* fill in your code here if you think this call should
+	   do anything */
+
+	return WERR_NOT_SUPPORTED;
+}
+
+/*******************************************************************
+ ********************************************************************/
+
+WERROR _winreg_LoadKey(pipes_struct *p, struct policy_handle *handle, struct winreg_String *keyname, struct winreg_String *filename)
+{
+	/* fill in your code here if you think this call should
+	   do anything */
+
+	return WERR_NOT_SUPPORTED;
+}
+
+/*******************************************************************
+ ********************************************************************/
+
+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)
+{
+	/* fill in your code here if you think this call should
+	   do anything */
+
+	return WERR_NOT_SUPPORTED;
+}
+
+/*******************************************************************
+ ********************************************************************/
+
+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)
+{
+	/* fill in your code here if you think this call should
+	   do anything */
+
+	return WERR_NOT_SUPPORTED;
+}
+
+/*******************************************************************
+ ********************************************************************/
+
+WERROR _winreg_QueryMultipleValues2(pipes_struct *p)
+{
+	/* fill in your code here if you think this call should
+	   do anything */
+
+	return WERR_NOT_SUPPORTED;
+}
+