git.samba.org / samba.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
s3-secrets: only include secrets.h when needed.
[samba.git] / source3 / rpc_server / srv_spoolss_nt.c
diff --git a/source3/rpc_server/srv_spoolss_nt.c b/source3/rpc_server/srv_spoolss_nt.c
index 27bd5aef958d1aa7f3b4b6a7f1cdbba08e46929c..7ada5fdb9a366e9343a9cc3728ab1e6b0e2340aa 100644 (file)
--- a/source3/rpc_server/srv_spoolss_nt.c
+++ b/source3/rpc_server/srv_spoolss_nt.c
@@ -28,13 +28,17 @@
    up, all the errors returned are DOS errors, not NT status codes. */
 
 #include "includes.h"
    up, all the errors returned are DOS errors, not NT status codes. */
 
 #include "includes.h"
+#include "nt_printing.h"
 #include "srv_spoolss_util.h"
 #include "../librpc/gen_ndr/srv_spoolss.h"
 #include "../librpc/gen_ndr/cli_spoolss.h"
 #include "rpc_client/init_spoolss.h"
 #include "librpc/gen_ndr/messaging.h"
 #include "srv_spoolss_util.h"
 #include "../librpc/gen_ndr/srv_spoolss.h"
 #include "../librpc/gen_ndr/cli_spoolss.h"
 #include "rpc_client/init_spoolss.h"
 #include "librpc/gen_ndr/messaging.h"
+#include "librpc/gen_ndr/ndr_security.h"
 #include "registry.h"
 #include "registry/reg_objects.h"
 #include "registry.h"
 #include "registry/reg_objects.h"
+#include "include/printing.h"
+#include "secrets.h"
 
 /* macros stolen from s4 spoolss server */
 #define SPOOLSS_BUFFER_UNION(fn,info,level) \
 
 /* macros stolen from s4 spoolss server */
 #define SPOOLSS_BUFFER_UNION(fn,info,level) \
@@ -48,18 +52,9 @@
 
 #define SPOOLSS_BUFFER_OK(val_true,val_false) ((r->in.offered >= *r->out.needed)?val_true:val_false)
 
 
 #define SPOOLSS_BUFFER_OK(val_true,val_false) ((r->in.offered >= *r->out.needed)?val_true:val_false)
 
-
-extern userdom_struct current_user_info;
-
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_RPC_SRV
 
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_RPC_SRV
 
-#ifndef MAX_OPEN_PRINTER_EXS
-#define MAX_OPEN_PRINTER_EXS 50
-#endif
-
-#define MAGIC_DISPLAY_FREQUENCY 0xfade2bad
-
 static Printer_entry *printers_list;
 
 typedef struct _counter_printer_0 {
 static Printer_entry *printers_list;
 
 typedef struct _counter_printer_0 {
@@ -76,9 +71,23 @@ static struct rpc_pipe_client *notify_cli_pipe; /* print notify back-channel pip
 static uint32_t smb_connections = 0;
 
 
 static uint32_t smb_connections = 0;
 
 
-/* in printing/nt_printing.c */
+/* Map generic permissions to printer object specific permissions */
+
+const struct standard_mapping printer_std_mapping = {
+       PRINTER_READ,
+       PRINTER_WRITE,
+       PRINTER_EXECUTE,
+       PRINTER_ALL_ACCESS
+};
+
+/* Map generic permissions to print server object specific permissions */
 
 
-extern struct standard_mapping printer_std_mapping, printserver_std_mapping;
+const struct standard_mapping printserver_std_mapping = {
+       SERVER_READ,
+       SERVER_WRITE,
+       SERVER_EXECUTE,
+       SERVER_ALL_ACCESS
+};
 
 /* API table for Xcv Monitor functions */
 
 
 /* API table for Xcv Monitor functions */
 
@@ -223,7 +232,6 @@ static int printer_entry_destructor(Printer_entry *Printer)
        Printer->notify.client_connected = false;
 
        TALLOC_FREE(Printer->devmode);
        Printer->notify.client_connected = false;
 
        TALLOC_FREE(Printer->devmode);
-       free_a_printer( &Printer->printer_info, 2 );
 
        /* Remove from the internal list. */
        DLIST_REMOVE(printers_list, Printer);
 
        /* Remove from the internal list. */
        DLIST_REMOVE(printers_list, Printer);
@@ -234,7 +242,7 @@ static int printer_entry_destructor(Printer_entry *Printer)
   find printer index by handle
 ****************************************************************************/
 
   find printer index by handle
 ****************************************************************************/
 
-static Printer_entry *find_printer_index_by_hnd(pipes_struct *p,
+static Printer_entry *find_printer_index_by_hnd(struct pipes_struct *p,
                                                struct policy_handle *hnd)
 {
        Printer_entry *find_printer = NULL;
                                                struct policy_handle *hnd)
 {
        Printer_entry *find_printer = NULL;
@@ -251,7 +259,7 @@ static Printer_entry *find_printer_index_by_hnd(pipes_struct *p,
  Close printer index by handle.
 ****************************************************************************/
 
  Close printer index by handle.
 ****************************************************************************/
 
-static bool close_printer_handle(pipes_struct *p, struct policy_handle *hnd)
+static bool close_printer_handle(struct pipes_struct *p, struct policy_handle *hnd)
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
 
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
 
@@ -332,9 +340,10 @@ static WERROR delete_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const c
  Delete a printer given a handle.
 ****************************************************************************/
 
  Delete a printer given a handle.
 ****************************************************************************/
 
-static WERROR delete_printer_handle(pipes_struct *p, struct policy_handle *hnd)
+static WERROR delete_printer_handle(struct pipes_struct *p, struct policy_handle *hnd)
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
+       WERROR result;
 
        if (!Printer) {
                DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n",
 
        if (!Printer) {
                DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n",
@@ -357,7 +366,9 @@ static WERROR delete_printer_handle(pipes_struct *p, struct policy_handle *hnd)
        /* this does not need a become root since the access check has been
           done on the handle already */
 
        /* this does not need a become root since the access check has been
           done on the handle already */
 
-       if (del_a_printer( Printer->sharename ) != 0) {
+       result = winreg_delete_printer_key(p->mem_ctx, p->server_info,
+                                          Printer->sharename, "");
+       if (!W_ERROR_IS_OK(result)) {
                DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
                return WERR_BADFID;
        }
                DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
                return WERR_BADFID;
        }
@@ -370,7 +381,7 @@ static WERROR delete_printer_handle(pipes_struct *p, struct policy_handle *hnd)
  Return the snum of a printer corresponding to an handle.
 ****************************************************************************/
 
  Return the snum of a printer corresponding to an handle.
 ****************************************************************************/
 
-static bool get_printer_snum(pipes_struct *p, struct policy_handle *hnd,
+static bool get_printer_snum(struct pipes_struct *p, struct policy_handle *hnd,
                             int *number, struct share_params **params)
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
                             int *number, struct share_params **params)
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
@@ -437,7 +448,7 @@ static bool set_printer_hnd_name(TALLOC_CTX *mem_ctx,
        int n_services=lp_numservices();
        char *aprinter;
        const char *printername;
        int n_services=lp_numservices();
        char *aprinter;
        const char *printername;
-       const char *servername;
+       const char *servername = NULL;
        fstring sname;
        bool found = false;
        struct spoolss_PrinterInfo2 *info2 = NULL;
        fstring sname;
        bool found = false;
        struct spoolss_PrinterInfo2 *info2 = NULL;
@@ -518,7 +529,7 @@ static bool set_printer_hnd_name(TALLOC_CTX *mem_ctx,
                                            sname,
                                            &info2);
                if ( !W_ERROR_IS_OK(result) ) {
                                            sname,
                                            &info2);
                if ( !W_ERROR_IS_OK(result) ) {
-                       DEBUG(0,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
+                       DEBUG(2,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
                                 sname, win_errstr(result)));
                        continue;
                }
                                 sname, win_errstr(result)));
                        continue;
                }
@@ -556,7 +567,7 @@ static bool set_printer_hnd_name(TALLOC_CTX *mem_ctx,
  Find first available printer slot. creates a printer handle for you.
  ****************************************************************************/
 
  Find first available printer slot. creates a printer handle for you.
  ****************************************************************************/
 
-static bool open_printer_hnd(pipes_struct *p, struct policy_handle *hnd,
+static bool open_printer_hnd(struct pipes_struct *p, struct policy_handle *hnd,
                             const char *name, uint32_t access_granted)
 {
        Printer_entry *new_printer;
                             const char *name, uint32_t access_granted)
 {
        Printer_entry *new_printer;
@@ -666,12 +677,13 @@ static bool is_monitoring_event(Printer_entry *p, uint16_t notify_type,
 #define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
        _data->data.devmode.devmode = _devmode;
 
 #define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
        _data->data.devmode.devmode = _devmode;
 
-#define SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(_data, _size, _sd) \
+#define SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(_data, _sd) \
        _data->data.sd.sd = dup_sec_desc(mem_ctx, _sd); \
        if (!_data->data.sd.sd) { \
                _data->data.sd.sd_size = 0; \
        } \
        _data->data.sd.sd = dup_sec_desc(mem_ctx, _sd); \
        if (!_data->data.sd.sd) { \
                _data->data.sd.sd_size = 0; \
        } \
-       _data->data.sd.sd_size = _size;
+       _data->data.sd.sd_size = \
+               ndr_size_security_descriptor(_data->data.sd.sd, 0);
 
 static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
                                   struct tm *t,
 
 static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
                                   struct tm *t,
@@ -937,10 +949,9 @@ static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MS
        return ctr->num_groups;
 }
 
        return ctr->num_groups;
 }
 
-void construct_info_data(struct spoolss_Notify *info_data,
-                        enum spoolss_NotifyType type,
-                        uint16_t field,
-                        int id);
+static void construct_info_data(struct spoolss_Notify *info_data,
+                               enum spoolss_NotifyType type,
+                               uint16_t field, int id);
 
 /***********************************************************************
  Send a change notication message on all handles which have a call
 
 /***********************************************************************
  Send a change notication message on all handles which have a call
@@ -1283,47 +1294,76 @@ void do_drv_upgrade_printer(struct messaging_context *msg,
                            struct server_id server_id,
                            DATA_BLOB *data)
 {
                            struct server_id server_id,
                            DATA_BLOB *data)
 {
-       fstring drivername;
+       TALLOC_CTX *tmp_ctx;
+       struct auth_serversupplied_info *server_info = NULL;
+       struct spoolss_PrinterInfo2 *pinfo2;
+       NTSTATUS status;
+       WERROR result;
+       const char *drivername;
        int snum;
        int n_services = lp_numservices();
        size_t len;
 
        int snum;
        int n_services = lp_numservices();
        size_t len;
 
+       tmp_ctx = talloc_new(NULL);
+       if (!tmp_ctx) return;
+
+       status = make_server_info_system(tmp_ctx, &server_info);
+       if (!NT_STATUS_IS_OK(status)) {
+               DEBUG(0, ("do_drv_upgrade_printer: "
+                         "Could not create system server_info\n"));
+               goto done;
+       }
+
        len = MIN(data->length,sizeof(drivername)-1);
        len = MIN(data->length,sizeof(drivername)-1);
-       strncpy(drivername, (const char *)data->data, len);
+       drivername = talloc_strndup(tmp_ctx, (const char *)data->data, len);
+       if (!drivername) {
+               DEBUG(0, ("do_drv_upgrade_printer: Out of memoery ?!\n"));
+               goto done;
+       }
 
 
-       DEBUG(10,("do_drv_upgrade_printer: Got message for new driver [%s]\n", drivername ));
+       DEBUG(10, ("do_drv_upgrade_printer: "
+                  "Got message for new driver [%s]\n", drivername));
 
        /* Iterate the printer list */
 
 
        /* Iterate the printer list */
 
-       for (snum=0; snum<n_services; snum++)
-       {
-               if (lp_snum_ok(snum) && lp_print_ok(snum) )
-               {
-                       WERROR result;
-                       NT_PRINTER_INFO_LEVEL *printer = NULL;
+       for (snum = 0; snum < n_services; snum++) {
+               if (!lp_snum_ok(snum) || !lp_print_ok(snum)) {
+                       continue;
+               }
 
 
-                       result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
-                       if (!W_ERROR_IS_OK(result))
-                               continue;
+               result = winreg_get_printer(tmp_ctx, server_info, NULL,
+                                           lp_const_servicename(snum),
+                                           &pinfo2);
 
 
-                       if (printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername))
-                       {
-                               DEBUG(6,("Updating printer [%s]\n", printer->info_2->printername));
+               if (!W_ERROR_IS_OK(result)) {
+                       continue;
+               }
 
 
-                               /* all we care about currently is the change_id */
+               if (!pinfo2->drivername) {
+                       continue;
+               }
 
 
-                               result = mod_a_printer(printer, 2);
-                               if (!W_ERROR_IS_OK(result)) {
-                                       DEBUG(3,("do_drv_upgrade_printer: mod_a_printer() failed with status [%s]\n",
-                                               win_errstr(result)));
-                               }
-                       }
+               if (strcmp(drivername, pinfo2->drivername) != 0) {
+                       continue;
+               }
+
+               DEBUG(6,("Updating printer [%s]\n", pinfo2->printername));
+
+               /* all we care about currently is the change_id */
+               result = winreg_printer_update_changeid(tmp_ctx,
+                                                       server_info,
+                                                       pinfo2->printername);
 
 
-                       free_a_printer(&printer, 2);
+               if (!W_ERROR_IS_OK(result)) {
+                       DEBUG(3, ("do_drv_upgrade_printer: "
+                                 "Failed to update changeid [%s]\n",
+                                 win_errstr(result)));
                }
        }
 
        /* all done */
                }
        }
 
        /* all done */
+done:
+       talloc_free(tmp_ctx);
 }
 
 /********************************************************************
 }
 
 /********************************************************************
@@ -1357,7 +1397,7 @@ void update_monitored_printq_cache( void )
  _spoolss_OpenPrinter
 ****************************************************************/
 
  _spoolss_OpenPrinter
 ****************************************************************/
 
-WERROR _spoolss_OpenPrinter(pipes_struct *p,
+WERROR _spoolss_OpenPrinter(struct pipes_struct *p,
                            struct spoolss_OpenPrinter *r)
 {
        struct spoolss_OpenPrinterEx e;
                            struct spoolss_OpenPrinter *r)
 {
        struct spoolss_OpenPrinterEx e;
@@ -1425,7 +1465,7 @@ static WERROR copy_devicemode(TALLOC_CTX *mem_ctx,
  _spoolss_OpenPrinterEx
 ****************************************************************/
 
  _spoolss_OpenPrinterEx
 ****************************************************************/
 
-WERROR _spoolss_OpenPrinterEx(pipes_struct *p,
+WERROR _spoolss_OpenPrinterEx(struct pipes_struct *p,
                              struct spoolss_OpenPrinterEx *r)
 {
        int snum;
                              struct spoolss_OpenPrinterEx *r)
 {
        int snum;
@@ -1659,7 +1699,7 @@ WERROR _spoolss_OpenPrinterEx(pipes_struct *p,
  _spoolss_ClosePrinter
 ****************************************************************/
 
  _spoolss_ClosePrinter
 ****************************************************************/
 
-WERROR _spoolss_ClosePrinter(pipes_struct *p,
+WERROR _spoolss_ClosePrinter(struct pipes_struct *p,
                             struct spoolss_ClosePrinter *r)
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
                             struct spoolss_ClosePrinter *r)
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
@@ -1689,7 +1729,7 @@ WERROR _spoolss_ClosePrinter(pipes_struct *p,
  _spoolss_DeletePrinter
 ****************************************************************/
 
  _spoolss_DeletePrinter
 ****************************************************************/
 
-WERROR _spoolss_DeletePrinter(pipes_struct *p,
+WERROR _spoolss_DeletePrinter(struct pipes_struct *p,
                              struct spoolss_DeletePrinter *r)
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
                              struct spoolss_DeletePrinter *r)
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
@@ -1750,7 +1790,7 @@ static int get_version_id(const char *arch)
  _spoolss_DeletePrinterDriver
 ****************************************************************/
 
  _spoolss_DeletePrinterDriver
 ****************************************************************/
 
-WERROR _spoolss_DeletePrinterDriver(pipes_struct *p,
+WERROR _spoolss_DeletePrinterDriver(struct pipes_struct *p,
                                    struct spoolss_DeletePrinterDriver *r)
 {
 
                                    struct spoolss_DeletePrinterDriver *r)
 {
 
@@ -1843,7 +1883,7 @@ done:
  _spoolss_DeletePrinterDriverEx
 ****************************************************************/
 
  _spoolss_DeletePrinterDriverEx
 ****************************************************************/
 
-WERROR _spoolss_DeletePrinterDriverEx(pipes_struct *p,
+WERROR _spoolss_DeletePrinterDriverEx(struct pipes_struct *p,
                                      struct spoolss_DeletePrinterDriverEx *r)
 {
        struct spoolss_DriverInfo8      *info = NULL;
                                      struct spoolss_DeletePrinterDriverEx *r)
 {
        struct spoolss_DriverInfo8      *info = NULL;
@@ -1996,19 +2036,6 @@ done:
 }
 
 
 }
 
 
-/****************************************************************************
- Internal routine for storing printerdata
- ***************************************************************************/
-
-WERROR set_printer_dataex(NT_PRINTER_INFO_LEVEL *printer,
-                         const char *key, const char *value,
-                         uint32_t type, uint8_t *data, int real_len)
-{
-       /* the registry objects enforce uniqueness based on value name */
-
-       return add_printer_data( printer->info_2, key, value, type, data, real_len );
-}
-
 /********************************************************************
  GetPrinterData on a printer server Handle.
 ********************************************************************/
 /********************************************************************
  GetPrinterData on a printer server Handle.
 ********************************************************************/
@@ -2153,7 +2180,7 @@ static WERROR getprinterdata_printer_server(TALLOC_CTX *mem_ctx,
  _spoolss_GetPrinterData
 ****************************************************************/
 
  _spoolss_GetPrinterData
 ****************************************************************/
 
-WERROR _spoolss_GetPrinterData(pipes_struct *p,
+WERROR _spoolss_GetPrinterData(struct pipes_struct *p,
                               struct spoolss_GetPrinterData *r)
 {
        struct spoolss_GetPrinterDataEx r2;
                               struct spoolss_GetPrinterData *r)
 {
        struct spoolss_GetPrinterDataEx r2;
@@ -2358,7 +2385,7 @@ static struct spoolss_NotifyOption *dup_spoolss_NotifyOption(TALLOC_CTX *mem_ctx
  * called from api_spoolss_rffpcnex
 ****************************************************************/
 
  * called from api_spoolss_rffpcnex
 ****************************************************************/
 
-WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct *p,
+WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct pipes_struct *p,
                                                     struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
 {
        int snum = -1;
                                                     struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
 {
        int snum = -1;
@@ -2418,10 +2445,10 @@ WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct *p,
 static void spoolss_notify_server_name(int snum,
                                       struct spoolss_Notify *data,
                                       print_queue_struct *queue,
 static void spoolss_notify_server_name(int snum,
                                       struct spoolss_Notify *data,
                                       print_queue_struct *queue,
-                                      NT_PRINTER_INFO_LEVEL *printer,
+                                      struct spoolss_PrinterInfo2 *pinfo2,
                                       TALLOC_CTX *mem_ctx)
 {
                                       TALLOC_CTX *mem_ctx)
 {
-       SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->servername);
+       SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->servername);
 }
 
 /*******************************************************************
 }
 
 /*******************************************************************
@@ -2431,14 +2458,14 @@ static void spoolss_notify_server_name(int snum,
 static void spoolss_notify_printer_name(int snum,
                                        struct spoolss_Notify *data,
                                        print_queue_struct *queue,
 static void spoolss_notify_printer_name(int snum,
                                        struct spoolss_Notify *data,
                                        print_queue_struct *queue,
-                                       NT_PRINTER_INFO_LEVEL *printer,
+                                       struct spoolss_PrinterInfo2 *pinfo2,
                                        TALLOC_CTX *mem_ctx)
 {
        /* the notify name should not contain the \\server\ part */
                                        TALLOC_CTX *mem_ctx)
 {
        /* the notify name should not contain the \\server\ part */
-       char *p = strrchr(printer->info_2->printername, '\\');
+       const char *p = strrchr(pinfo2->printername, '\\');
 
        if (!p) {
 
        if (!p) {
-               p = printer->info_2->printername;
+               p = pinfo2->printername;
        } else {
                p++;
        }
        } else {
                p++;
        }
@@ -2453,7 +2480,7 @@ static void spoolss_notify_printer_name(int snum,
 static void spoolss_notify_share_name(int snum,
                                      struct spoolss_Notify *data,
                                      print_queue_struct *queue,
 static void spoolss_notify_share_name(int snum,
                                      struct spoolss_Notify *data,
                                      print_queue_struct *queue,
-                                     NT_PRINTER_INFO_LEVEL *printer,
+                                     struct spoolss_PrinterInfo2 *pinfo2,
                                      TALLOC_CTX *mem_ctx)
 {
        SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(snum));
                                      TALLOC_CTX *mem_ctx)
 {
        SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(snum));
@@ -2466,10 +2493,10 @@ static void spoolss_notify_share_name(int snum,
 static void spoolss_notify_port_name(int snum,
                                     struct spoolss_Notify *data,
                                     print_queue_struct *queue,
 static void spoolss_notify_port_name(int snum,
                                     struct spoolss_Notify *data,
                                     print_queue_struct *queue,
-                                    NT_PRINTER_INFO_LEVEL *printer,
+                                    struct spoolss_PrinterInfo2 *pinfo2,
                                     TALLOC_CTX *mem_ctx)
 {
                                     TALLOC_CTX *mem_ctx)
 {
-       SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->portname);
+       SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->portname);
 }
 
 /*******************************************************************
 }
 
 /*******************************************************************
@@ -2480,10 +2507,10 @@ static void spoolss_notify_port_name(int snum,
 static void spoolss_notify_driver_name(int snum,
                                       struct spoolss_Notify *data,
                                       print_queue_struct *queue,
 static void spoolss_notify_driver_name(int snum,
                                       struct spoolss_Notify *data,
                                       print_queue_struct *queue,
-                                      NT_PRINTER_INFO_LEVEL *printer,
+                                      struct spoolss_PrinterInfo2 *pinfo2,
                                       TALLOC_CTX *mem_ctx)
 {
                                       TALLOC_CTX *mem_ctx)
 {
-       SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->drivername);
+       SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->drivername);
 }
 
 /*******************************************************************
 }
 
 /*******************************************************************
@@ -2493,18 +2520,18 @@ static void spoolss_notify_driver_name(int snum,
 static void spoolss_notify_comment(int snum,
                                   struct spoolss_Notify *data,
                                   print_queue_struct *queue,
 static void spoolss_notify_comment(int snum,
                                   struct spoolss_Notify *data,
                                   print_queue_struct *queue,
-                                  NT_PRINTER_INFO_LEVEL *printer,
+                                  struct spoolss_PrinterInfo2 *pinfo2,
                                   TALLOC_CTX *mem_ctx)
 {
                                   TALLOC_CTX *mem_ctx)
 {
-       char *p;
+       const char *p;
 
 
-       if (*printer->info_2->comment == '\0') {
+       if (*pinfo2->comment == '\0') {
                p = lp_comment(snum);
        } else {
                p = lp_comment(snum);
        } else {
-               p = printer->info_2->comment;
+               p = pinfo2->comment;
        }
 
        }
 
-       SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->comment);
+       SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
 }
 
 /*******************************************************************
 }
 
 /*******************************************************************
@@ -2515,10 +2542,10 @@ static void spoolss_notify_comment(int snum,
 static void spoolss_notify_location(int snum,
                                    struct spoolss_Notify *data,
                                    print_queue_struct *queue,
 static void spoolss_notify_location(int snum,
                                    struct spoolss_Notify *data,
                                    print_queue_struct *queue,
-                                   NT_PRINTER_INFO_LEVEL *printer,
+                                   struct spoolss_PrinterInfo2 *pinfo2,
                                    TALLOC_CTX *mem_ctx)
 {
                                    TALLOC_CTX *mem_ctx)
 {
-       SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->location);
+       SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->location);
 }
 
 /*******************************************************************
 }
 
 /*******************************************************************
@@ -2529,7 +2556,7 @@ static void spoolss_notify_location(int snum,
 static void spoolss_notify_devmode(int snum,
                                   struct spoolss_Notify *data,
                                   print_queue_struct *queue,
 static void spoolss_notify_devmode(int snum,
                                   struct spoolss_Notify *data,
                                   print_queue_struct *queue,
-                                  NT_PRINTER_INFO_LEVEL *printer,
+                                  struct spoolss_PrinterInfo2 *pinfo2,
                                   TALLOC_CTX *mem_ctx)
 {
        /* for a dummy implementation we have to zero the fields */
                                   TALLOC_CTX *mem_ctx)
 {
        /* for a dummy implementation we have to zero the fields */
@@ -2543,10 +2570,10 @@ static void spoolss_notify_devmode(int snum,
 static void spoolss_notify_sepfile(int snum,
                                   struct spoolss_Notify *data,
                                   print_queue_struct *queue,
 static void spoolss_notify_sepfile(int snum,
                                   struct spoolss_Notify *data,
                                   print_queue_struct *queue,
-                                  NT_PRINTER_INFO_LEVEL *printer,
+                                  struct spoolss_PrinterInfo2 *pinfo2,
                                   TALLOC_CTX *mem_ctx)
 {
                                   TALLOC_CTX *mem_ctx)
 {
-       SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->sepfile);
+       SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->sepfile);
 }
 
 /*******************************************************************
 }
 
 /*******************************************************************
@@ -2557,10 +2584,10 @@ static void spoolss_notify_sepfile(int snum,
 static void spoolss_notify_print_processor(int snum,
                                           struct spoolss_Notify *data,
                                           print_queue_struct *queue,
 static void spoolss_notify_print_processor(int snum,
                                           struct spoolss_Notify *data,
                                           print_queue_struct *queue,
-                                          NT_PRINTER_INFO_LEVEL *printer,
+                                          struct spoolss_PrinterInfo2 *pinfo2,
                                           TALLOC_CTX *mem_ctx)
 {
                                           TALLOC_CTX *mem_ctx)
 {
-       SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->printprocessor);
+       SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->printprocessor);
 }
 
 /*******************************************************************
 }
 
 /*******************************************************************
@@ -2571,10 +2598,10 @@ static void spoolss_notify_print_processor(int snum,
 static void spoolss_notify_parameters(int snum,
                                      struct spoolss_Notify *data,
                                      print_queue_struct *queue,
 static void spoolss_notify_parameters(int snum,
                                      struct spoolss_Notify *data,
                                      print_queue_struct *queue,
-                                     NT_PRINTER_INFO_LEVEL *printer,
+                                     struct spoolss_PrinterInfo2 *pinfo2,
                                      TALLOC_CTX *mem_ctx)
 {
                                      TALLOC_CTX *mem_ctx)
 {
-       SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->parameters);
+       SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->parameters);
 }
 
 /*******************************************************************
 }
 
 /*******************************************************************
@@ -2585,10 +2612,10 @@ static void spoolss_notify_parameters(int snum,
 static void spoolss_notify_datatype(int snum,
                                    struct spoolss_Notify *data,
                                    print_queue_struct *queue,
 static void spoolss_notify_datatype(int snum,
                                    struct spoolss_Notify *data,
                                    print_queue_struct *queue,
-                                   NT_PRINTER_INFO_LEVEL *printer,
+                                   struct spoolss_PrinterInfo2 *pinfo2,
                                    TALLOC_CTX *mem_ctx)
 {
                                    TALLOC_CTX *mem_ctx)
 {
-       SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->datatype);
+       SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->datatype);
 }
 
 /*******************************************************************
 }
 
 /*******************************************************************
@@ -2600,12 +2627,10 @@ static void spoolss_notify_datatype(int snum,
 static void spoolss_notify_security_desc(int snum,
                                         struct spoolss_Notify *data,
                                         print_queue_struct *queue,
 static void spoolss_notify_security_desc(int snum,
                                         struct spoolss_Notify *data,
                                         print_queue_struct *queue,
-                                        NT_PRINTER_INFO_LEVEL *printer,
+                                        struct spoolss_PrinterInfo2 *pinfo2,
                                         TALLOC_CTX *mem_ctx)
 {
                                         TALLOC_CTX *mem_ctx)
 {
-       SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data,
-                                         printer->info_2->secdesc_buf->sd_size,
-                                         printer->info_2->secdesc_buf->sd);
+       SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data, pinfo2->secdesc);
 }
 
 /*******************************************************************
 }
 
 /*******************************************************************
@@ -2616,10 +2641,10 @@ static void spoolss_notify_security_desc(int snum,
 static void spoolss_notify_attributes(int snum,
                                      struct spoolss_Notify *data,
                                      print_queue_struct *queue,
 static void spoolss_notify_attributes(int snum,
                                      struct spoolss_Notify *data,
                                      print_queue_struct *queue,
-                                     NT_PRINTER_INFO_LEVEL *printer,
+                                     struct spoolss_PrinterInfo2 *pinfo2,
                                      TALLOC_CTX *mem_ctx)
 {
                                      TALLOC_CTX *mem_ctx)
 {
-       SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->attributes);
+       SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->attributes);
 }
 
 /*******************************************************************
 }
 
 /*******************************************************************
@@ -2629,10 +2654,10 @@ static void spoolss_notify_attributes(int snum,
 static void spoolss_notify_priority(int snum,
                                    struct spoolss_Notify *data,
                                    print_queue_struct *queue,
 static void spoolss_notify_priority(int snum,
                                    struct spoolss_Notify *data,
                                    print_queue_struct *queue,
-                                   NT_PRINTER_INFO_LEVEL *printer,
+                                   struct spoolss_PrinterInfo2 *pinfo2,
                                    TALLOC_CTX *mem_ctx)
 {
                                    TALLOC_CTX *mem_ctx)
 {
-       SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->priority);
+       SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->priority);
 }
 
 /*******************************************************************
 }
 
 /*******************************************************************
@@ -2642,10 +2667,10 @@ static void spoolss_notify_priority(int snum,
 static void spoolss_notify_default_priority(int snum,
                                            struct spoolss_Notify *data,
                                            print_queue_struct *queue,
 static void spoolss_notify_default_priority(int snum,
                                            struct spoolss_Notify *data,
                                            print_queue_struct *queue,
-                                           NT_PRINTER_INFO_LEVEL *printer,
+                                           struct spoolss_PrinterInfo2 *pinfo2,
                                            TALLOC_CTX *mem_ctx)
 {
                                            TALLOC_CTX *mem_ctx)
 {
-       SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->default_priority);
+       SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->defaultpriority);
 }
 
 /*******************************************************************
 }
 
 /*******************************************************************
@@ -2655,10 +2680,10 @@ static void spoolss_notify_default_priority(int snum,
 static void spoolss_notify_start_time(int snum,
                                      struct spoolss_Notify *data,
                                      print_queue_struct *queue,
 static void spoolss_notify_start_time(int snum,
                                      struct spoolss_Notify *data,
                                      print_queue_struct *queue,
-                                     NT_PRINTER_INFO_LEVEL *printer,
+                                     struct spoolss_PrinterInfo2 *pinfo2,
                                      TALLOC_CTX *mem_ctx)
 {
                                      TALLOC_CTX *mem_ctx)
 {
-       SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->starttime);
+       SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->starttime);
 }
 
 /*******************************************************************
 }
 
 /*******************************************************************
@@ -2668,10 +2693,10 @@ static void spoolss_notify_start_time(int snum,
 static void spoolss_notify_until_time(int snum,
                                      struct spoolss_Notify *data,
                                      print_queue_struct *queue,
 static void spoolss_notify_until_time(int snum,
                                      struct spoolss_Notify *data,
                                      print_queue_struct *queue,
-                                     NT_PRINTER_INFO_LEVEL *printer,
+                                     struct spoolss_PrinterInfo2 *pinfo2,
                                      TALLOC_CTX *mem_ctx)
 {
                                      TALLOC_CTX *mem_ctx)
 {
-       SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->untiltime);
+       SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->untiltime);
 }
 
 /*******************************************************************
 }
 
 /*******************************************************************
@@ -2681,7 +2706,7 @@ static void spoolss_notify_until_time(int snum,
 static void spoolss_notify_status(int snum,
                                  struct spoolss_Notify *data,
                                  print_queue_struct *queue,
 static void spoolss_notify_status(int snum,
                                  struct spoolss_Notify *data,
                                  print_queue_struct *queue,
-                                 NT_PRINTER_INFO_LEVEL *printer,
+                                 struct spoolss_PrinterInfo2 *pinfo2,
                                  TALLOC_CTX *mem_ctx)
 {
        print_status_struct status;
                                  TALLOC_CTX *mem_ctx)
 {
        print_status_struct status;
@@ -2697,7 +2722,7 @@ static void spoolss_notify_status(int snum,
 static void spoolss_notify_cjobs(int snum,
                                 struct spoolss_Notify *data,
                                 print_queue_struct *queue,
 static void spoolss_notify_cjobs(int snum,
                                 struct spoolss_Notify *data,
                                 print_queue_struct *queue,
-                                NT_PRINTER_INFO_LEVEL *printer,
+                                struct spoolss_PrinterInfo2 *pinfo2,
                                 TALLOC_CTX *mem_ctx)
 {
        SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, print_queue_length(snum, NULL));
                                 TALLOC_CTX *mem_ctx)
 {
        SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, print_queue_length(snum, NULL));
@@ -2710,12 +2735,12 @@ static void spoolss_notify_cjobs(int snum,
 static void spoolss_notify_average_ppm(int snum,
                                       struct spoolss_Notify *data,
                                       print_queue_struct *queue,
 static void spoolss_notify_average_ppm(int snum,
                                       struct spoolss_Notify *data,
                                       print_queue_struct *queue,
-                                      NT_PRINTER_INFO_LEVEL *printer,
+                                      struct spoolss_PrinterInfo2 *pinfo2,
                                       TALLOC_CTX *mem_ctx)
 {
        /* always respond 8 pages per minutes */
        /* a little hard ! */
                                       TALLOC_CTX *mem_ctx)
 {
        /* always respond 8 pages per minutes */
        /* a little hard ! */
-       SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->averageppm);
+       SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->averageppm);
 }
 
 /*******************************************************************
 }
 
 /*******************************************************************
@@ -2725,7 +2750,7 @@ static void spoolss_notify_average_ppm(int snum,
 static void spoolss_notify_username(int snum,
                                    struct spoolss_Notify *data,
                                    print_queue_struct *queue,
 static void spoolss_notify_username(int snum,
                                    struct spoolss_Notify *data,
                                    print_queue_struct *queue,
-                                   NT_PRINTER_INFO_LEVEL *printer,
+                                   struct spoolss_PrinterInfo2 *pinfo2,
                                    TALLOC_CTX *mem_ctx)
 {
        SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
                                    TALLOC_CTX *mem_ctx)
 {
        SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
@@ -2738,7 +2763,7 @@ static void spoolss_notify_username(int snum,
 static void spoolss_notify_job_status(int snum,
                                      struct spoolss_Notify *data,
                                      print_queue_struct *queue,
 static void spoolss_notify_job_status(int snum,
                                      struct spoolss_Notify *data,
                                      print_queue_struct *queue,
-                                     NT_PRINTER_INFO_LEVEL *printer,
+                                     struct spoolss_PrinterInfo2 *pinfo2,
                                      TALLOC_CTX *mem_ctx)
 {
        SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
                                      TALLOC_CTX *mem_ctx)
 {
        SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
@@ -2751,7 +2776,7 @@ static void spoolss_notify_job_status(int snum,
 static void spoolss_notify_job_name(int snum,
                                    struct spoolss_Notify *data,
                                    print_queue_struct *queue,
 static void spoolss_notify_job_name(int snum,
                                    struct spoolss_Notify *data,
                                    print_queue_struct *queue,
-                                   NT_PRINTER_INFO_LEVEL *printer,
+                                   struct spoolss_PrinterInfo2 *pinfo2,
                                    TALLOC_CTX *mem_ctx)
 {
        SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
                                    TALLOC_CTX *mem_ctx)
 {
        SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
@@ -2764,7 +2789,7 @@ static void spoolss_notify_job_name(int snum,
 static void spoolss_notify_job_status_string(int snum,
                                             struct spoolss_Notify *data,
                                             print_queue_struct *queue,
 static void spoolss_notify_job_status_string(int snum,
                                             struct spoolss_Notify *data,
                                             print_queue_struct *queue,
-                                            NT_PRINTER_INFO_LEVEL *printer,
+                                            struct spoolss_PrinterInfo2 *pinfo2,
                                             TALLOC_CTX *mem_ctx)
 {
        /*
                                             TALLOC_CTX *mem_ctx)
 {
        /*
@@ -2802,7 +2827,7 @@ static void spoolss_notify_job_status_string(int snum,
 static void spoolss_notify_job_time(int snum,
                                    struct spoolss_Notify *data,
                                    print_queue_struct *queue,
 static void spoolss_notify_job_time(int snum,
                                    struct spoolss_Notify *data,
                                    print_queue_struct *queue,
-                                   NT_PRINTER_INFO_LEVEL *printer,
+                                   struct spoolss_PrinterInfo2 *pinfo2,
                                    TALLOC_CTX *mem_ctx)
 {
        SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
                                    TALLOC_CTX *mem_ctx)
 {
        SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
@@ -2815,7 +2840,7 @@ static void spoolss_notify_job_time(int snum,
 static void spoolss_notify_job_size(int snum,
                                    struct spoolss_Notify *data,
                                    print_queue_struct *queue,
 static void spoolss_notify_job_size(int snum,
                                    struct spoolss_Notify *data,
                                    print_queue_struct *queue,
-                                   NT_PRINTER_INFO_LEVEL *printer,
+                                   struct spoolss_PrinterInfo2 *pinfo2,
                                    TALLOC_CTX *mem_ctx)
 {
        SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
                                    TALLOC_CTX *mem_ctx)
 {
        SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
@@ -2827,7 +2852,7 @@ static void spoolss_notify_job_size(int snum,
 static void spoolss_notify_total_pages(int snum,
                                struct spoolss_Notify *data,
                                print_queue_struct *queue,
 static void spoolss_notify_total_pages(int snum,
                                struct spoolss_Notify *data,
                                print_queue_struct *queue,
-                               NT_PRINTER_INFO_LEVEL *printer,
+                               struct spoolss_PrinterInfo2 *pinfo2,
                                TALLOC_CTX *mem_ctx)
 {
        SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
                                TALLOC_CTX *mem_ctx)
 {
        SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
@@ -2839,7 +2864,7 @@ static void spoolss_notify_total_pages(int snum,
 static void spoolss_notify_pages_printed(int snum,
                                struct spoolss_Notify *data,
                                print_queue_struct *queue,
 static void spoolss_notify_pages_printed(int snum,
                                struct spoolss_Notify *data,
                                print_queue_struct *queue,
-                               NT_PRINTER_INFO_LEVEL *printer,
+                               struct spoolss_PrinterInfo2 *pinfo2,
                                TALLOC_CTX *mem_ctx)
 {
        /* Add code when back-end tracks this */
                                TALLOC_CTX *mem_ctx)
 {
        /* Add code when back-end tracks this */
@@ -2853,7 +2878,7 @@ static void spoolss_notify_pages_printed(int snum,
 static void spoolss_notify_job_position(int snum,
                                        struct spoolss_Notify *data,
                                        print_queue_struct *queue,
 static void spoolss_notify_job_position(int snum,
                                        struct spoolss_Notify *data,
                                        print_queue_struct *queue,
-                                       NT_PRINTER_INFO_LEVEL *printer,
+                                       struct spoolss_PrinterInfo2 *pinfo2,
                                        TALLOC_CTX *mem_ctx)
 {
        SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->job);
                                        TALLOC_CTX *mem_ctx)
 {
        SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->job);
@@ -2866,7 +2891,7 @@ static void spoolss_notify_job_position(int snum,
 static void spoolss_notify_submitted_time(int snum,
                                          struct spoolss_Notify *data,
                                          print_queue_struct *queue,
 static void spoolss_notify_submitted_time(int snum,
                                          struct spoolss_Notify *data,
                                          print_queue_struct *queue,
-                                         NT_PRINTER_INFO_LEVEL *printer,
+                                         struct spoolss_PrinterInfo2 *pinfo2,
                                          TALLOC_CTX *mem_ctx)
 {
        data->data.string.string = NULL;
                                          TALLOC_CTX *mem_ctx)
 {
        data->data.string.string = NULL;
@@ -2886,7 +2911,8 @@ struct s_notify_info_data_table
        enum spoolss_NotifyTable variable_type;
        void (*fn) (int snum, struct spoolss_Notify *data,
                    print_queue_struct *queue,
        enum spoolss_NotifyTable variable_type;
        void (*fn) (int snum, struct spoolss_Notify *data,
                    print_queue_struct *queue,
-                   NT_PRINTER_INFO_LEVEL *printer, TALLOC_CTX *mem_ctx);
+                   struct spoolss_PrinterInfo2 *pinfo2,
+                   TALLOC_CTX *mem_ctx);
 };
 
 /* A table describing the various print notification constants and
 };
 
 /* A table describing the various print notification constants and
@@ -2991,10 +3017,9 @@ static bool search_notify(enum spoolss_NotifyType type,
 /****************************************************************************
 ****************************************************************************/
 
 /****************************************************************************
 ****************************************************************************/
 
-void construct_info_data(struct spoolss_Notify *info_data,
-                        enum spoolss_NotifyType type,
-                        uint16_t field,
-                        int id)
+static void construct_info_data(struct spoolss_Notify *info_data,
+                               enum spoolss_NotifyType type,
+                               uint16_t field, int id)
 {
        info_data->type                 = type;
        info_data->field.field          = field;
 {
        info_data->type                 = type;
        info_data->field.field          = field;
@@ -3010,6 +3035,7 @@ void construct_info_data(struct spoolss_Notify *info_data,
 
 static bool construct_notify_printer_info(Printer_entry *print_hnd,
                                          struct spoolss_NotifyInfo *info,
 
 static bool construct_notify_printer_info(Printer_entry *print_hnd,
                                          struct spoolss_NotifyInfo *info,
+                                         struct spoolss_PrinterInfo2 *pinfo2,
                                          int snum,
                                          const struct spoolss_NotifyOptionType *option_type,
                                          uint32_t id,
                                          int snum,
                                          const struct spoolss_NotifyOptionType *option_type,
                                          uint32_t id,
@@ -3020,7 +3046,6 @@ static bool construct_notify_printer_info(Printer_entry *print_hnd,
        uint16_t field;
 
        struct spoolss_Notify *current_data;
        uint16_t field;
 
        struct spoolss_Notify *current_data;
-       NT_PRINTER_INFO_LEVEL *printer = NULL;
        print_queue_struct *queue=NULL;
 
        type = option_type->type;
        print_queue_struct *queue=NULL;
 
        type = option_type->type;
@@ -3029,9 +3054,6 @@ static bool construct_notify_printer_info(Printer_entry *print_hnd,
                (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
                option_type->count, lp_servicename(snum)));
 
                (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
                option_type->count, lp_servicename(snum)));
 
-       if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &printer, 2, lp_const_servicename(snum))))
-               return false;
-
        for(field_num=0; field_num < option_type->count; field_num++) {
                field = option_type->fields[field_num].field;
 
        for(field_num=0; field_num < option_type->count; field_num++) {
                field = option_type->fields[field_num].field;
 
@@ -3045,7 +3067,6 @@ static bool construct_notify_printer_info(Printer_entry *print_hnd,
                                                      info->count + 1);
                if (info->notifies == NULL) {
                        DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
                                                      info->count + 1);
                if (info->notifies == NULL) {
                        DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
-                       free_a_printer(&printer, 2);
                        return false;
                }
 
                        return false;
                }
 
@@ -3053,16 +3074,17 @@ static bool construct_notify_printer_info(Printer_entry *print_hnd,
 
                construct_info_data(current_data, type, field, id);
 
 
                construct_info_data(current_data, type, field, id);
 
-               DEBUG(10,("construct_notify_printer_info: calling [%s]  snum=%d  printername=[%s])\n",
-                               notify_info_data_table[j].name, snum, printer->info_2->printername ));
+               DEBUG(10, ("construct_notify_printer_info: "
+                          "calling [%s]  snum=%d  printername=[%s])\n",
+                          notify_info_data_table[j].name, snum,
+                          pinfo2->printername));
 
                notify_info_data_table[j].fn(snum, current_data, queue,
 
                notify_info_data_table[j].fn(snum, current_data, queue,
-                                            printer, mem_ctx);
+                                            pinfo2, mem_ctx);
 
                info->count++;
        }
 
 
                info->count++;
        }
 
-       free_a_printer(&printer, 2);
        return true;
 }
 
        return true;
 }
 
@@ -3074,7 +3096,7 @@ static bool construct_notify_printer_info(Printer_entry *print_hnd,
 
 static bool construct_notify_jobs_info(print_queue_struct *queue,
                                       struct spoolss_NotifyInfo *info,
 
 static bool construct_notify_jobs_info(print_queue_struct *queue,
                                       struct spoolss_NotifyInfo *info,
-                                      NT_PRINTER_INFO_LEVEL *printer,
+                                      struct spoolss_PrinterInfo2 *pinfo2,
                                       int snum,
                                       const struct spoolss_NotifyOptionType *option_type,
                                       uint32_t id,
                                       int snum,
                                       const struct spoolss_NotifyOptionType *option_type,
                                       uint32_t id,
@@ -3111,7 +3133,7 @@ static bool construct_notify_jobs_info(print_queue_struct *queue,
 
                construct_info_data(current_data, type, field, id);
                notify_info_data_table[j].fn(snum, current_data, queue,
 
                construct_info_data(current_data, type, field, id);
                notify_info_data_table[j].fn(snum, current_data, queue,
-                                            printer, mem_ctx);
+                                            pinfo2, mem_ctx);
                info->count++;
        }
 
                info->count++;
        }
 
@@ -3148,7 +3170,7 @@ static bool construct_notify_jobs_info(print_queue_struct *queue,
  *
  ********************************************************************/
 
  *
  ********************************************************************/
 
-static WERROR printserver_notify_info(pipes_struct *p,
+static WERROR printserver_notify_info(struct pipes_struct *p,
                                      struct policy_handle *hnd,
                                      struct spoolss_NotifyInfo *info,
                                      TALLOC_CTX *mem_ctx)
                                      struct policy_handle *hnd,
                                      struct spoolss_NotifyInfo *info,
                                      TALLOC_CTX *mem_ctx)
@@ -3159,6 +3181,8 @@ static WERROR printserver_notify_info(pipes_struct *p,
        int i;
        struct spoolss_NotifyOption *option;
        struct spoolss_NotifyOptionType option_type;
        int i;
        struct spoolss_NotifyOption *option;
        struct spoolss_NotifyOptionType option_type;
+       struct spoolss_PrinterInfo2 *pinfo2 = NULL;
+       WERROR result;
 
        DEBUG(4,("printserver_notify_info\n"));
 
 
        DEBUG(4,("printserver_notify_info\n"));
 
@@ -3183,10 +3207,32 @@ static WERROR printserver_notify_info(pipes_struct *p,
                if (option_type.type != PRINTER_NOTIFY_TYPE)
                        continue;
 
                if (option_type.type != PRINTER_NOTIFY_TYPE)
                        continue;
 
-               for (snum=0; snum<n_services; snum++)
-               {
-                       if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) )
-                               construct_notify_printer_info ( Printer, info, snum, &option_type, snum, mem_ctx );
+               for (snum = 0; snum < n_services; snum++) {
+                       if (!lp_browseable(snum) ||
+                           !lp_snum_ok(snum) ||
+                           !lp_print_ok(snum)) {
+                               continue; /* skip */
+                       }
+
+                       /* Maybe we should use the SYSTEM server_info here... */
+                       result = winreg_get_printer(mem_ctx, p->server_info,
+                                                   Printer->servername,
+                                                   lp_servicename(snum),
+                                                   &pinfo2);
+                       if (!W_ERROR_IS_OK(result)) {
+                               DEBUG(4, ("printserver_notify_info: "
+                                         "Failed to get printer [%s]\n",
+                                         lp_servicename(snum)));
+                               continue;
+                       }
+
+
+                       construct_notify_printer_info(Printer, info,
+                                                     pinfo2, snum,
+                                                     &option_type, snum,
+                                                     mem_ctx);
+
+                       TALLOC_FREE(pinfo2);
                }
        }
 
                }
        }
 
@@ -3215,7 +3261,8 @@ static WERROR printserver_notify_info(pipes_struct *p,
  *
  ********************************************************************/
 
  *
  ********************************************************************/
 
-static WERROR printer_notify_info(pipes_struct *p, struct policy_handle *hnd,
+static WERROR printer_notify_info(struct pipes_struct *p,
+                                 struct policy_handle *hnd,
                                  struct spoolss_NotifyInfo *info,
                                  TALLOC_CTX *mem_ctx)
 {
                                  struct spoolss_NotifyInfo *info,
                                  TALLOC_CTX *mem_ctx)
 {
@@ -3228,6 +3275,8 @@ static WERROR printer_notify_info(pipes_struct *p, struct policy_handle *hnd,
        int count,j;
        print_queue_struct *queue=NULL;
        print_status_struct status;
        int count,j;
        print_queue_struct *queue=NULL;
        print_status_struct status;
+       struct spoolss_PrinterInfo2 *pinfo2 = NULL;
+       WERROR result;
 
        DEBUG(4,("printer_notify_info\n"));
 
 
        DEBUG(4,("printer_notify_info\n"));
 
@@ -3249,40 +3298,42 @@ static WERROR printer_notify_info(pipes_struct *p, struct policy_handle *hnd,
 
        get_printer_snum(p, hnd, &snum, NULL);
 
 
        get_printer_snum(p, hnd, &snum, NULL);
 
+       /* Maybe we should use the SYSTEM server_info here... */
+       result = winreg_get_printer(mem_ctx, p->server_info,
+                                   Printer->servername,
+                                   lp_servicename(snum), &pinfo2);
+       if (!W_ERROR_IS_OK(result)) {
+               return WERR_BADFID;
+       }
+
        for (i=0; i<option->count; i++) {
                option_type = option->types[i];
 
                switch (option_type.type) {
                case PRINTER_NOTIFY_TYPE:
        for (i=0; i<option->count; i++) {
                option_type = option->types[i];
 
                switch (option_type.type) {
                case PRINTER_NOTIFY_TYPE:
-                       if(construct_notify_printer_info(Printer, info, snum,
-                                                        &option_type, id,
-                                                        mem_ctx))
+                       if (construct_notify_printer_info(Printer, info,
+                                                         pinfo2, snum,
+                                                         &option_type, id,
+                                                         mem_ctx)) {
                                id--;
                                id--;
+                       }
                        break;
 
                        break;
 
-               case JOB_NOTIFY_TYPE: {
-                       NT_PRINTER_INFO_LEVEL *printer = NULL;
+               case JOB_NOTIFY_TYPE:
 
                        count = print_queue_status(snum, &queue, &status);
 
 
                        count = print_queue_status(snum, &queue, &status);
 
-                       if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))))
-                               goto done;
-
                        for (j=0; j<count; j++) {
                                construct_notify_jobs_info(&queue[j], info,
                        for (j=0; j<count; j++) {
                                construct_notify_jobs_info(&queue[j], info,
-                                                          printer, snum,
+                                                          pinfo2, snum,
                                                           &option_type,
                                                           queue[j].job,
                                                           mem_ctx);
                        }
 
                                                           &option_type,
                                                           queue[j].job,
                                                           mem_ctx);
                        }
 
-                       free_a_printer(&printer, 2);
-
-               done:
                        SAFE_FREE(queue);
                        break;
                }
                        SAFE_FREE(queue);
                        break;
                }
-               }
        }
 
        /*
        }
 
        /*
@@ -3299,6 +3350,8 @@ static WERROR printer_notify_info(pipes_struct *p, struct policy_handle *hnd,
                info->data[i].id, info->data[i].size, info->data[i].enc_type));
        }
        */
                info->data[i].id, info->data[i].size, info->data[i].enc_type));
        }
        */
+
+       talloc_free(pinfo2);
        return WERR_OK;
 }
 
        return WERR_OK;
 }
 
@@ -3306,7 +3359,7 @@ static WERROR printer_notify_info(pipes_struct *p, struct policy_handle *hnd,
  _spoolss_RouterRefreshPrinterChangeNotify
 ****************************************************************/
 
  _spoolss_RouterRefreshPrinterChangeNotify
 ****************************************************************/
 
-WERROR _spoolss_RouterRefreshPrinterChangeNotify(pipes_struct *p,
+WERROR _spoolss_RouterRefreshPrinterChangeNotify(struct pipes_struct *p,
                                                 struct spoolss_RouterRefreshPrinterChangeNotify *r)
 {
        struct spoolss_NotifyInfo *info;
                                                 struct spoolss_RouterRefreshPrinterChangeNotify *r)
 {
        struct spoolss_NotifyInfo *info;
@@ -3455,36 +3508,6 @@ static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
 }
 
 
 }
 
 
-/****************************************************************************
- Create a spoolss_DeviceMode struct. Returns talloced memory.
-****************************************************************************/
-
-struct spoolss_DeviceMode *construct_dev_mode(TALLOC_CTX *mem_ctx,
-                                             const char *servicename)
-{
-       NT_PRINTER_INFO_LEVEL   *printer = NULL;
-       struct spoolss_DeviceMode *devmode = NULL;
-
-       DEBUG(7,("construct_dev_mode\n"));
-
-       DEBUGADD(8,("getting printer characteristics\n"));
-
-       if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
-               return NULL;
-
-       if (!printer->info_2->devmode) {
-               DEBUG(5, ("BONG! There was no device mode!\n"));
-               goto done;
-       }
-
-        devmode = talloc_steal(mem_ctx, printer->info_2->devmode);
-
-done:
-       free_a_printer(&printer,2);
-
-       return devmode;
-}
-
 /********************************************************************
  * construct_printer_info1
  * fill a spoolss_PrinterInfo1 struct
 /********************************************************************
  * construct_printer_info1
  * fill a spoolss_PrinterInfo1 struct
@@ -3685,9 +3708,19 @@ static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
                                      struct spoolss_PrinterInfo7 *r,
                                      int snum)
 {
                                      struct spoolss_PrinterInfo7 *r,
                                      int snum)
 {
+       struct auth_serversupplied_info *server_info;
        struct GUID guid;
        struct GUID guid;
+       NTSTATUS status;
 
 
-       if (is_printer_published(print_hnd, snum, &guid)) {
+       status = make_server_info_system(mem_ctx, &server_info);
+       if (!NT_STATUS_IS_OK(status)) {
+               DEBUG(0, ("construct_printer_info7: "
+                         "Could not create system server_info\n"));
+               return WERR_NOMEM;
+       }
+
+       if (is_printer_published(mem_ctx, server_info, print_hnd->servername,
+                                lp_servicename(snum), &guid, NULL)) {
                r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
                r->action = DSPRINT_PUBLISH;
        } else {
                r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
                r->action = DSPRINT_PUBLISH;
        } else {
@@ -3696,6 +3729,7 @@ static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
        }
        W_ERROR_HAVE_NO_MEMORY(r->guid);
 
        }
        W_ERROR_HAVE_NO_MEMORY(r->guid);
 
+       TALLOC_FREE(server_info);
        return WERR_OK;
 }
 
        return WERR_OK;
 }
 
@@ -4044,7 +4078,7 @@ static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
  _spoolss_EnumPrinters
 ****************************************************************/
 
  _spoolss_EnumPrinters
 ****************************************************************/
 
-WERROR _spoolss_EnumPrinters(pipes_struct *p,
+WERROR _spoolss_EnumPrinters(struct pipes_struct *p,
                             struct spoolss_EnumPrinters *r)
 {
        const char *name = NULL;
                             struct spoolss_EnumPrinters *r)
 {
        const char *name = NULL;
@@ -4128,7 +4162,7 @@ WERROR _spoolss_EnumPrinters(pipes_struct *p,
  _spoolss_GetPrinter
 ****************************************************************/
 
  _spoolss_GetPrinter
 ****************************************************************/
 
-WERROR _spoolss_GetPrinter(pipes_struct *p,
+WERROR _spoolss_GetPrinter(struct pipes_struct *p,
                           struct spoolss_GetPrinter *r)
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
                           struct spoolss_GetPrinter *r)
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
@@ -4223,30 +4257,52 @@ WERROR _spoolss_GetPrinter(pipes_struct *p,
 /********************************************************************
  ********************************************************************/
 
 /********************************************************************
  ********************************************************************/
 
-static const char **string_array_from_driver_info(TALLOC_CTX *mem_ctx,
+#define FILL_DRIVER_STRING(mem_ctx, in, out) \
+       do { \
+               if (in && strlen(in)) { \
+                       out = talloc_strdup(mem_ctx, in); \
+               } else { \
+                       out = talloc_strdup(mem_ctx, ""); \
+               } \
+               W_ERROR_HAVE_NO_MEMORY(out); \
+       } while (0);
+
+#define FILL_DRIVER_UNC_STRING(mem_ctx, server, arch, ver, in, out) \
+       do { \
+               if (in && strlen(in)) { \
+                       out = talloc_asprintf(mem_ctx, "\\\\%s\\print$\\%s\\%d\\%s", server, get_short_archi(arch), ver, in); \
+               } else { \
+                       out = talloc_strdup(mem_ctx, ""); \
+               } \
+               W_ERROR_HAVE_NO_MEMORY(out); \
+       } while (0);
+
+static WERROR string_array_from_driver_info(TALLOC_CTX *mem_ctx,
                                                  const char **string_array,
                                                  const char **string_array,
-                                                 const char *cservername)
+                                                 const char ***presult,
+                                                 const char *cservername,
+                                                 const char *arch,
+                                                 int version)
 {
        int i, num_strings = 0;
        const char **array = NULL;
 
 {
        int i, num_strings = 0;
        const char **array = NULL;
 
-       if (!string_array) {
-               return NULL;
+       if (string_array == NULL) {
+               return WERR_INVALID_PARAMETER;;
        }
 
        for (i=0; string_array[i] && string_array[i][0] != '\0'; i++) {
        }
 
        for (i=0; string_array[i] && string_array[i][0] != '\0'; i++) {
+               const char *str = NULL;
 
 
-               const char *str = talloc_asprintf(mem_ctx, "\\\\%s%s",
-                                                 cservername, string_array[i]);
-               if (!str) {
-                       TALLOC_FREE(array);
-                       return NULL;
+               if (cservername == NULL || arch == NULL) {
+                       FILL_DRIVER_STRING(mem_ctx, string_array[i], str);
+               } else {
+                       FILL_DRIVER_UNC_STRING(mem_ctx, cservername, arch, version, string_array[i], str);
                }
 
                }
 
-
                if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
                        TALLOC_FREE(array);
                if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
                        TALLOC_FREE(array);
-                       return NULL;
+                       return WERR_NOMEM;
                }
        }
 
                }
        }
 
@@ -4255,28 +4311,12 @@ static const char **string_array_from_driver_info(TALLOC_CTX *mem_ctx,
                             &array, &num_strings);
        }
 
                             &array, &num_strings);
        }
 
-       return array;
-}
-
-#define FILL_DRIVER_STRING(mem_ctx, in, out) \
-       do { \
-               if (in && strlen(in)) { \
-                       out = talloc_strdup(mem_ctx, in); \
-                       W_ERROR_HAVE_NO_MEMORY(out); \
-               } else { \
-                       out = NULL; \
-               } \
-       } while (0);
+       if (presult) {
+               *presult = array;
+       }
 
 
-#define FILL_DRIVER_UNC_STRING(mem_ctx, server, in, out) \
-       do { \
-               if (in && strlen(in)) { \
-                       out = talloc_asprintf(mem_ctx, "\\\\%s%s", server, in); \
-               } else { \
-                       out = talloc_strdup(mem_ctx, ""); \
-               } \
-               W_ERROR_HAVE_NO_MEMORY(out); \
-       } while (0);
+       return WERR_OK;
+}
 
 /********************************************************************
  * fill a spoolss_DriverInfo1 struct
 
 /********************************************************************
  * fill a spoolss_DriverInfo1 struct
@@ -4313,14 +4353,20 @@ static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
        W_ERROR_HAVE_NO_MEMORY(r->architecture);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
        W_ERROR_HAVE_NO_MEMORY(r->architecture);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->driver_path,
                               r->driver_path);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
                               driver->driver_path,
                               r->driver_path);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->data_file,
                               r->data_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
                               driver->data_file,
                               r->data_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->config_file,
                               r->config_file);
 
                               driver->config_file,
                               r->config_file);
 
@@ -4346,18 +4392,26 @@ static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
        W_ERROR_HAVE_NO_MEMORY(r->architecture);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
        W_ERROR_HAVE_NO_MEMORY(r->architecture);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->driver_path,
                               r->driver_path);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
                               driver->driver_path,
                               r->driver_path);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->data_file,
                               r->data_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
                               driver->data_file,
                               r->data_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->config_file,
                               r->config_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
                               driver->config_file,
                               r->config_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->help_file,
                               r->help_file);
 
                               driver->help_file,
                               r->help_file);
 
@@ -4369,10 +4423,12 @@ static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
                           driver->default_datatype,
                           r->default_datatype);
 
                           driver->default_datatype,
                           r->default_datatype);
 
-       r->dependent_files = string_array_from_driver_info(mem_ctx,
-                                                          driver->dependent_files,
-                                                          cservername);
-       return WERR_OK;
+       return string_array_from_driver_info(mem_ctx,
+                                            driver->dependent_files,
+                                            &r->dependent_files,
+                                            cservername,
+                                            driver->architecture,
+                                            driver->version);
 }
 
 /********************************************************************
 }
 
 /********************************************************************
@@ -4385,6 +4441,7 @@ static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
                                        const char *servername)
 {
        const char *cservername = canon_servername(servername);
                                        const char *servername)
 {
        const char *cservername = canon_servername(servername);
+       WERROR result;
 
        r->version              = driver->version;
 
 
        r->version              = driver->version;
 
@@ -4394,24 +4451,38 @@ static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
        W_ERROR_HAVE_NO_MEMORY(r->architecture);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
        W_ERROR_HAVE_NO_MEMORY(r->architecture);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->driver_path,
                               r->driver_path);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
                               driver->driver_path,
                               r->driver_path);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->data_file,
                               r->data_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
                               driver->data_file,
                               r->data_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->config_file,
                               r->config_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
                               driver->config_file,
                               r->config_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->help_file,
                               r->help_file);
 
                               driver->help_file,
                               r->help_file);
 
-       r->dependent_files = string_array_from_driver_info(mem_ctx,
-                                                          driver->dependent_files,
-                                                          cservername);
+       result = string_array_from_driver_info(mem_ctx,
+                                              driver->dependent_files,
+                                              &r->dependent_files,
+                                              cservername,
+                                              driver->architecture,
+                                              driver->version);
+       if (!W_ERROR_IS_OK(result)) {
+               return result;
+       }
 
        FILL_DRIVER_STRING(mem_ctx,
                           driver->monitor_name,
 
        FILL_DRIVER_STRING(mem_ctx,
                           driver->monitor_name,
@@ -4421,11 +4492,13 @@ static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
                           driver->default_datatype,
                           r->default_datatype);
 
                           driver->default_datatype,
                           r->default_datatype);
 
-       r->previous_names = string_array_from_driver_info(mem_ctx,
-                                                         driver->previous_names,
-                                                         cservername);
 
 
-       return WERR_OK;
+       result = string_array_from_driver_info(mem_ctx,
+                                              driver->previous_names,
+                                              &r->previous_names,
+                                              NULL, NULL, 0);
+
+       return result;
 }
 
 /********************************************************************
 }
 
 /********************************************************************
@@ -4447,14 +4520,20 @@ static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
        W_ERROR_HAVE_NO_MEMORY(r->architecture);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
        W_ERROR_HAVE_NO_MEMORY(r->architecture);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->driver_path,
                               r->driver_path);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
                               driver->driver_path,
                               r->driver_path);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->data_file,
                               r->data_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
                               driver->data_file,
                               r->data_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->config_file,
                               r->config_file);
 
                               driver->config_file,
                               r->config_file);
 
@@ -4474,6 +4553,7 @@ static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
                                        const char *servername)
 {
        const char *cservername = canon_servername(servername);
                                        const char *servername)
 {
        const char *cservername = canon_servername(servername);
+       WERROR result;
 
        r->version              = driver->version;
 
 
        r->version              = driver->version;
 
@@ -4483,18 +4563,26 @@ static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
        W_ERROR_HAVE_NO_MEMORY(r->architecture);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
        W_ERROR_HAVE_NO_MEMORY(r->architecture);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->driver_path,
                               r->driver_path);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
                               driver->driver_path,
                               r->driver_path);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->data_file,
                               r->data_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
                               driver->data_file,
                               r->data_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->config_file,
                               r->config_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
                               driver->config_file,
                               r->config_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->help_file,
                               r->help_file);
 
                               driver->help_file,
                               r->help_file);
 
@@ -4506,12 +4594,23 @@ static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
                           driver->default_datatype,
                           r->default_datatype);
 
                           driver->default_datatype,
                           r->default_datatype);
 
-       r->dependent_files = string_array_from_driver_info(mem_ctx,
-                                                          driver->dependent_files,
-                                                          cservername);
-       r->previous_names = string_array_from_driver_info(mem_ctx,
-                                                         driver->previous_names,
-                                                         cservername);
+       result = string_array_from_driver_info(mem_ctx,
+                                              driver->dependent_files,
+                                              &r->dependent_files,
+                                              cservername,
+                                              driver->architecture,
+                                              driver->version);
+       if (!W_ERROR_IS_OK(result)) {
+               return result;
+       }
+
+       result = string_array_from_driver_info(mem_ctx,
+                                              driver->previous_names,
+                                              &r->previous_names,
+                                              NULL, NULL, 0);
+       if (!W_ERROR_IS_OK(result)) {
+               return result;
+       }
 
        r->driver_date          = driver->driver_date;
        r->driver_version       = driver->driver_version;
 
        r->driver_date          = driver->driver_date;
        r->driver_version       = driver->driver_version;
@@ -4542,6 +4641,7 @@ static WERROR fill_printer_driver_info8(TALLOC_CTX *mem_ctx,
                                        const char *servername)
 {
        const char *cservername = canon_servername(servername);
                                        const char *servername)
 {
        const char *cservername = canon_servername(servername);
+       WERROR result;
 
        r->version              = driver->version;
 
 
        r->version              = driver->version;
 
@@ -4551,18 +4651,26 @@ static WERROR fill_printer_driver_info8(TALLOC_CTX *mem_ctx,
        W_ERROR_HAVE_NO_MEMORY(r->architecture);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
        W_ERROR_HAVE_NO_MEMORY(r->architecture);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->driver_path,
                               r->driver_path);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
                               driver->driver_path,
                               r->driver_path);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->data_file,
                               r->data_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
                               driver->data_file,
                               r->data_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->config_file,
                               r->config_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
                               driver->config_file,
                               r->config_file);
 
        FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+                              driver->architecture,
+                              driver->version,
                               driver->help_file,
                               r->help_file);
 
                               driver->help_file,
                               r->help_file);
 
@@ -4574,12 +4682,23 @@ static WERROR fill_printer_driver_info8(TALLOC_CTX *mem_ctx,
                           driver->default_datatype,
                           r->default_datatype);
 
                           driver->default_datatype,
                           r->default_datatype);
 
-       r->dependent_files = string_array_from_driver_info(mem_ctx,
-                                                          driver->dependent_files,
-                                                          cservername);
-       r->previous_names = string_array_from_driver_info(mem_ctx,
-                                                         driver->previous_names,
-                                                         cservername);
+       result = string_array_from_driver_info(mem_ctx,
+                                              driver->dependent_files,
+                                              &r->dependent_files,
+                                              cservername,
+                                              driver->architecture,
+                                              driver->version);
+       if (!W_ERROR_IS_OK(result)) {
+               return result;
+       }
+
+       result = string_array_from_driver_info(mem_ctx,
+                                              driver->previous_names,
+                                              &r->previous_names,
+                                              NULL, NULL, 0);
+       if (!W_ERROR_IS_OK(result)) {
+               return result;
+       }
 
        r->driver_date          = driver->driver_date;
        r->driver_version       = driver->driver_version;
 
        r->driver_date          = driver->driver_date;
        r->driver_version       = driver->driver_version;
@@ -4604,9 +4723,13 @@ static WERROR fill_printer_driver_info8(TALLOC_CTX *mem_ctx,
                           driver->vendor_setup,
                           r->vendor_setup);
 
                           driver->vendor_setup,
                           r->vendor_setup);
 
-       r->color_profiles = string_array_from_driver_info(mem_ctx,
-                                                         driver->color_profiles,
-                                                         cservername);
+       result = string_array_from_driver_info(mem_ctx,
+                                              driver->color_profiles,
+                                              &r->color_profiles,
+                                              NULL, NULL, 0);
+       if (!W_ERROR_IS_OK(result)) {
+               return result;
+       }
 
        FILL_DRIVER_STRING(mem_ctx,
                           driver->inf_path,
 
        FILL_DRIVER_STRING(mem_ctx,
                           driver->inf_path,
@@ -4614,9 +4737,13 @@ static WERROR fill_printer_driver_info8(TALLOC_CTX *mem_ctx,
 
        r->printer_driver_attributes    = driver->printer_driver_attributes;
 
 
        r->printer_driver_attributes    = driver->printer_driver_attributes;
 
-       r->core_driver_dependencies = string_array_from_driver_info(mem_ctx,
-                                                                   driver->core_driver_dependencies,
-                                                                   cservername);
+       result = string_array_from_driver_info(mem_ctx,
+                                              driver->core_driver_dependencies,
+                                              &r->core_driver_dependencies,
+                                              NULL, NULL, 0);
+       if (!W_ERROR_IS_OK(result)) {
+               return result;
+       }
 
        r->min_inbox_driver_ver_date    = driver->min_inbox_driver_ver_date;
        r->min_inbox_driver_ver_version = driver->min_inbox_driver_ver_version;
 
        r->min_inbox_driver_ver_date    = driver->min_inbox_driver_ver_date;
        r->min_inbox_driver_ver_version = driver->min_inbox_driver_ver_version;
@@ -4777,9 +4904,14 @@ static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
                           driver->default_datatype,
                           r->default_datatype);
 
                           driver->default_datatype,
                           r->default_datatype);
 
-       r->previous_names = string_array_from_driver_info(mem_ctx,
-                                                         driver->previous_names,
-                                                         cservername);
+       result = string_array_from_driver_info(mem_ctx,
+                                              driver->previous_names,
+                                              &r->previous_names,
+                                              NULL, NULL, 0);
+       if (!W_ERROR_IS_OK(result)) {
+               return result;
+       }
+
        r->driver_date          = driver->driver_date;
        r->driver_version       = driver->driver_version;
 
        r->driver_date          = driver->driver_date;
        r->driver_version       = driver->driver_version;
 
@@ -4899,13 +5031,12 @@ static WERROR construct_printer_driver_info_level(TALLOC_CTX *mem_ctx,
  _spoolss_GetPrinterDriver2
 ****************************************************************/
 
  _spoolss_GetPrinterDriver2
 ****************************************************************/
 
-WERROR _spoolss_GetPrinterDriver2(pipes_struct *p,
+WERROR _spoolss_GetPrinterDriver2(struct pipes_struct *p,
                                  struct spoolss_GetPrinterDriver2 *r)
 {
        Printer_entry *printer;
        WERROR result;
 
                                  struct spoolss_GetPrinterDriver2 *r)
 {
        Printer_entry *printer;
        WERROR result;
 
-       const char *servername;
        int snum;
 
        /* that's an [in out] buffer */
        int snum;
 
        /* that's an [in out] buffer */
@@ -4925,15 +5056,13 @@ WERROR _spoolss_GetPrinterDriver2(pipes_struct *p,
        *r->out.server_major_version = 0;
        *r->out.server_minor_version = 0;
 
        *r->out.server_major_version = 0;
        *r->out.server_minor_version = 0;
 
-       servername = get_server_name(printer);
-
        if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
                return WERR_BADFID;
        }
 
        result = construct_printer_driver_info_level(p->mem_ctx, p->server_info,
                                                     r->in.level, r->out.info,
        if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
                return WERR_BADFID;
        }
 
        result = construct_printer_driver_info_level(p->mem_ctx, p->server_info,
                                                     r->in.level, r->out.info,
-                                                    snum, servername,
+                                                    snum, printer->servername,
                                                     r->in.architecture,
                                                     r->in.client_major_version);
        if (!W_ERROR_IS_OK(result)) {
                                                     r->in.architecture,
                                                     r->in.client_major_version);
        if (!W_ERROR_IS_OK(result)) {
@@ -4953,7 +5082,7 @@ WERROR _spoolss_GetPrinterDriver2(pipes_struct *p,
  _spoolss_StartPagePrinter
 ****************************************************************/
 
  _spoolss_StartPagePrinter
 ****************************************************************/
 
-WERROR _spoolss_StartPagePrinter(pipes_struct *p,
+WERROR _spoolss_StartPagePrinter(struct pipes_struct *p,
                                 struct spoolss_StartPagePrinter *r)
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
                                 struct spoolss_StartPagePrinter *r)
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
@@ -4972,7 +5101,7 @@ WERROR _spoolss_StartPagePrinter(pipes_struct *p,
  _spoolss_EndPagePrinter
 ****************************************************************/
 
  _spoolss_EndPagePrinter
 ****************************************************************/
 
-WERROR _spoolss_EndPagePrinter(pipes_struct *p,
+WERROR _spoolss_EndPagePrinter(struct pipes_struct *p,
                               struct spoolss_EndPagePrinter *r)
 {
        int snum;
                               struct spoolss_EndPagePrinter *r)
 {
        int snum;
@@ -4998,12 +5127,13 @@ WERROR _spoolss_EndPagePrinter(pipes_struct *p,
  _spoolss_StartDocPrinter
 ****************************************************************/
 
  _spoolss_StartDocPrinter
 ****************************************************************/
 
-WERROR _spoolss_StartDocPrinter(pipes_struct *p,
+WERROR _spoolss_StartDocPrinter(struct pipes_struct *p,
                                struct spoolss_StartDocPrinter *r)
 {
        struct spoolss_DocumentInfo1 *info_1;
        int snum;
        Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
                                struct spoolss_StartDocPrinter *r)
 {
        struct spoolss_DocumentInfo1 *info_1;
        int snum;
        Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
+       WERROR werr;
 
        if (!Printer) {
                DEBUG(2,("_spoolss_StartDocPrinter: "
 
        if (!Printer) {
                DEBUG(2,("_spoolss_StartDocPrinter: "
@@ -5012,6 +5142,13 @@ WERROR _spoolss_StartDocPrinter(pipes_struct *p,
                return WERR_BADFID;
        }
 
                return WERR_BADFID;
        }
 
+       if (Printer->jobid) {
+               DEBUG(2, ("_spoolss_StartDocPrinter: "
+                         "StartDocPrinter called twice! "
+                         "(existing jobid = %d)\n", Printer->jobid));
+               return WERR_INVALID_HANDLE;
+       }
+
        if (r->in.level != 1) {
                return WERR_UNKNOWN_LEVEL;
        }
        if (r->in.level != 1) {
                return WERR_UNKNOWN_LEVEL;
        }
@@ -5038,15 +5175,15 @@ WERROR _spoolss_StartDocPrinter(pipes_struct *p,
                return WERR_BADFID;
        }
 
                return WERR_BADFID;
        }
 
-       Printer->jobid = print_job_start(p->server_info, snum,
-                                        info_1->document_name,
-                                        Printer->devmode);
+       werr = print_job_start(p->server_info, snum,
+                               info_1->document_name, info_1->output_file,
+                               Printer->devmode, &Printer->jobid);
 
        /* An error occured in print_job_start() so return an appropriate
           NT error code. */
 
 
        /* An error occured in print_job_start() so return an appropriate
           NT error code. */
 
-       if (Printer->jobid == -1) {
-               return map_werror_from_unix(errno);
+       if (!W_ERROR_IS_OK(werr)) {
+               return werr;
        }
 
        Printer->document_started = true;
        }
 
        Printer->document_started = true;
@@ -5059,10 +5196,11 @@ WERROR _spoolss_StartDocPrinter(pipes_struct *p,
  _spoolss_EndDocPrinter
 ****************************************************************/
 
  _spoolss_EndDocPrinter
 ****************************************************************/
 
-WERROR _spoolss_EndDocPrinter(pipes_struct *p,
+WERROR _spoolss_EndDocPrinter(struct pipes_struct *p,
                              struct spoolss_EndDocPrinter *r)
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
                              struct spoolss_EndDocPrinter *r)
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
+       NTSTATUS status;
        int snum;
 
        if (!Printer) {
        int snum;
 
        if (!Printer) {
@@ -5076,17 +5214,22 @@ WERROR _spoolss_EndDocPrinter(pipes_struct *p,
        }
 
        Printer->document_started = false;
        }
 
        Printer->document_started = false;
-       print_job_end(snum, Printer->jobid, NORMAL_CLOSE);
-       /* error codes unhandled so far ... */
+       status = print_job_end(snum, Printer->jobid, NORMAL_CLOSE);
+       if (!NT_STATUS_IS_OK(status)) {
+               DEBUG(2, ("_spoolss_EndDocPrinter: "
+                         "print_job_end failed [%s]\n",
+                         nt_errstr(status)));
+       }
 
 
-       return WERR_OK;
+       Printer->jobid = 0;
+       return ntstatus_to_werror(status);
 }
 
 /****************************************************************
  _spoolss_WritePrinter
 ****************************************************************/
 
 }
 
 /****************************************************************
  _spoolss_WritePrinter
 ****************************************************************/
 
-WERROR _spoolss_WritePrinter(pipes_struct *p,
+WERROR _spoolss_WritePrinter(struct pipes_struct *p,
                             struct spoolss_WritePrinter *r)
 {
        ssize_t buffer_written;
                             struct spoolss_WritePrinter *r)
 {
        ssize_t buffer_written;
@@ -5103,6 +5246,7 @@ WERROR _spoolss_WritePrinter(pipes_struct *p,
        if (!get_printer_snum(p, r->in.handle, &snum, NULL))
                return WERR_BADFID;
 
        if (!get_printer_snum(p, r->in.handle, &snum, NULL))
                return WERR_BADFID;
 
+       /* print_job_write takes care of checking for PJOB_SMBD_SPOOLING */
        buffer_written = print_job_write(snum, Printer->jobid,
                                                   (const char *)r->in.data.data,
                                                   (SMB_OFF_T)-1,
        buffer_written = print_job_write(snum, Printer->jobid,
                                                   (const char *)r->in.data.data,
                                                   (SMB_OFF_T)-1,
@@ -5127,7 +5271,7 @@ WERROR _spoolss_WritePrinter(pipes_struct *p,
  ********************************************************************/
 
 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
  ********************************************************************/
 
 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
-                             pipes_struct *p)
+                             struct pipes_struct *p)
 {
        int snum;
        WERROR errcode = WERR_BADFUNC;
 {
        int snum;
        WERROR errcode = WERR_BADFUNC;
@@ -5167,7 +5311,7 @@ static WERROR control_printer(struct policy_handle *handle, uint32_t command,
  * for spooling"
 ****************************************************************/
 
  * for spooling"
 ****************************************************************/
 
-WERROR _spoolss_AbortPrinter(pipes_struct *p,
+WERROR _spoolss_AbortPrinter(struct pipes_struct *p,
                             struct spoolss_AbortPrinter *r)
 {
        Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
                             struct spoolss_AbortPrinter *r)
 {
        Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
@@ -5183,7 +5327,11 @@ WERROR _spoolss_AbortPrinter(pipes_struct *p,
        if (!get_printer_snum(p, r->in.handle, &snum, NULL))
                return WERR_BADFID;
 
        if (!get_printer_snum(p, r->in.handle, &snum, NULL))
                return WERR_BADFID;
 
-       print_job_delete(p->server_info, snum, Printer->jobid, &errcode );
+       if (!Printer->document_started) {
+               return WERR_SPL_NO_STARTDOC;
+       }
+
+       errcode = print_job_delete(p->server_info, snum, Printer->jobid);
 
        return errcode;
 }
 
        return errcode;
 }
@@ -5194,7 +5342,8 @@ WERROR _spoolss_AbortPrinter(pipes_struct *p,
  ********************************************************************/
 
 static WERROR update_printer_sec(struct policy_handle *handle,
  ********************************************************************/
 
 static WERROR update_printer_sec(struct policy_handle *handle,
-                                pipes_struct *p, struct sec_desc_buf *secdesc_ctr)
+                                struct pipes_struct *p,
+                                struct sec_desc_buf *secdesc_ctr)
 {
        struct spoolss_security_descriptor *new_secdesc = NULL;
        struct spoolss_security_descriptor *old_secdesc = NULL;
 {
        struct spoolss_security_descriptor *new_secdesc = NULL;
        struct spoolss_security_descriptor *old_secdesc = NULL;
@@ -5246,7 +5395,7 @@ static WERROR update_printer_sec(struct policy_handle *handle,
                struct security_acl *the_acl;
                int i;
 
                struct security_acl *the_acl;
                int i;
 
-               the_acl = secdesc_ctr->sd->dacl;
+               the_acl = old_secdesc->dacl;
                DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
                           printer, the_acl->num_aces));
 
                DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
                           printer, the_acl->num_aces));
 
@@ -5294,11 +5443,6 @@ static WERROR update_printer_sec(struct policy_handle *handle,
 
 /********************************************************************
  Canonicalize printer info from a client
 
 /********************************************************************
  Canonicalize printer info from a client
-
- ATTN: It does not matter what we set the servername to hear
- since we do the necessary work in get_a_printer() to set it to
- the correct value based on what the client sent in the
- _spoolss_open_printer_ex().
  ********************************************************************/
 
 static bool check_printer_ok(TALLOC_CTX *mem_ctx,
  ********************************************************************/
 
 static bool check_printer_ok(TALLOC_CTX *mem_ctx,
@@ -5403,7 +5547,8 @@ static WERROR add_port_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *p
 ****************************************************************************/
 
 bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token,
 ****************************************************************************/
 
 bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token,
-                     struct spoolss_SetPrinterInfo2 *info2)
+                     struct spoolss_SetPrinterInfo2 *info2,
+                     const char *remote_machine)
 {
        char *cmd = lp_addprinter_cmd();
        char **qlines;
 {
        char *cmd = lp_addprinter_cmd();
        char **qlines;
@@ -5413,18 +5558,10 @@ bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token,
        int fd;
        SE_PRIV se_printop = SE_PRINT_OPERATOR;
        bool is_print_op = false;
        int fd;
        SE_PRIV se_printop = SE_PRINT_OPERATOR;
        bool is_print_op = false;
-       char *remote_machine = talloc_strdup(ctx, "%m");
 
        if (!remote_machine) {
                return false;
        }
 
        if (!remote_machine) {
                return false;
        }
-       remote_machine = talloc_sub_basic(ctx,
-                               current_user_info.smb_name,
-                               current_user_info.domain,
-                               remote_machine);
-       if (!remote_machine) {
-               return false;
-       }
 
        command = talloc_asprintf(ctx,
                        "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
 
        command = talloc_asprintf(ctx,
                        "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
@@ -5459,7 +5596,6 @@ bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token,
        DEBUGADD(10,("returned [%d]\n", ret));
 
        TALLOC_FREE(command);
        DEBUGADD(10,("returned [%d]\n", ret));
 
        TALLOC_FREE(command);
-       TALLOC_FREE(remote_machine);
 
        if ( ret != 0 ) {
                if (fd != -1)
 
        if ( ret != 0 ) {
                if (fd != -1)
@@ -5491,220 +5627,362 @@ bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token,
        return true;
 }
 
        return true;
 }
 
-
-/********************************************************************
- * Called by spoolss_api_setprinter
- * when updating a printer description.
- ********************************************************************/
-
-static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
-                            struct spoolss_SetPrinterInfoCtr *info_ctr,
-                            struct spoolss_DeviceMode *devmode)
+static WERROR update_dsspooler(TALLOC_CTX *mem_ctx,
+                              struct auth_serversupplied_info *server_info,
+                              int snum,
+                              struct spoolss_SetPrinterInfo2 *printer,
+                              struct spoolss_PrinterInfo2 *old_printer)
 {
 {
-       uint32_t printer_mask = SPOOLSS_PRINTER_INFO_ALL;
-       struct spoolss_SetPrinterInfo2 *printer = info_ctr->info.info2;
-       struct spoolss_PrinterInfo2 *old_printer;
-       Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
-       const char *servername = NULL;
-       int snum;
-       WERROR result;
+       bool force_update = (old_printer == NULL);
+       const char *dnsdomname;
+       const char *longname;
+       const char *uncname;
+       const char *spooling;
        DATA_BLOB buffer;
        DATA_BLOB buffer;
-       fstring asc_buffer;
+       WERROR result = WERR_OK;
 
 
-       DEBUG(8,("update_printer\n"));
+       if (force_update || !strequal(printer->drivername, old_printer->drivername)) {
+               push_reg_sz(mem_ctx, &buffer, printer->drivername);
+               winreg_set_printer_dataex(mem_ctx,
+                                         server_info,
+                                         printer->sharename,
+                                         SPOOL_DSSPOOLER_KEY,
+                                         SPOOL_REG_DRIVERNAME,
+                                         REG_SZ,
+                                         buffer.data,
+                                         buffer.length);
 
 
-       result = WERR_OK;
+               if (!force_update) {
+                       DEBUG(10,("update_printer: changing driver [%s]!  Sending event!\n",
+                               printer->drivername));
 
 
-       if (!Printer) {
-               result = WERR_BADFID;
-               goto done;
+                       notify_printer_driver(snum, printer->drivername);
+               }
        }
 
        }
 
-       if (!get_printer_snum(p, handle, &snum, NULL)) {
-               result = WERR_BADFID;
-               goto done;
-       }
+       if (force_update || !strequal(printer->comment, old_printer->comment)) {
+               push_reg_sz(mem_ctx, &buffer, printer->comment);
+               winreg_set_printer_dataex(mem_ctx,
+                                         server_info,
+                                         printer->sharename,
+                                         SPOOL_DSSPOOLER_KEY,
+                                         SPOOL_REG_DESCRIPTION,
+                                         REG_SZ,
+                                         buffer.data,
+                                         buffer.length);
 
 
-       if (Printer != NULL || Printer->servername != NULL) {
-               servername = Printer->servername;
+               if (!force_update) {
+                       notify_printer_comment(snum, printer->comment);
+               }
        }
 
        }
 
-       result = winreg_get_printer(p->mem_ctx,
-                                   p->server_info,
-                                   servername,
-                                   lp_const_servicename(snum),
-                                   &old_printer);
-       if (!W_ERROR_IS_OK(result)) {
-               result = WERR_BADFID;
-               goto done;
-       }
+       if (force_update || !strequal(printer->sharename, old_printer->sharename)) {
+               push_reg_sz(mem_ctx, &buffer, printer->sharename);
+               winreg_set_printer_dataex(mem_ctx,
+                                         server_info,
+                                         printer->sharename,
+                                         SPOOL_DSSPOOLER_KEY,
+                                         SPOOL_REG_PRINTSHARENAME,
+                                         REG_SZ,
+                                         buffer.data,
+                                         buffer.length);
 
 
-       /* Do sanity check on the requested changes for Samba */
-       if (!check_printer_ok(p->mem_ctx, printer, snum)) {
-               result = WERR_INVALID_PARAM;
-               goto done;
+               if (!force_update) {
+                       notify_printer_sharename(snum, printer->sharename);
+               }
        }
 
        }
 
-       /* FIXME!!! If the driver has changed we really should verify that
-          it is installed before doing much else   --jerry */
+       if (force_update || !strequal(printer->printername, old_printer->printername)) {
+               const char *p;
 
 
-       /* Check calling user has permission to update printer description */
-       if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
-               DEBUG(3, ("update_printer: printer property change denied by handle\n"));
-               result = WERR_ACCESS_DENIED;
-               goto done;
-       }
+               p = strrchr(printer->printername, '\\' );
+               if (p != NULL) {
+                       p++;
+               } else {
+                       p = printer->printername;
+               }
 
 
-       /* Call addprinter hook */
-       /* Check changes to see if this is really needed */
+               push_reg_sz(mem_ctx, &buffer, p);
+               winreg_set_printer_dataex(mem_ctx,
+                                         server_info,
+                                         printer->sharename,
+                                         SPOOL_DSSPOOLER_KEY,
+                                         SPOOL_REG_PRINTERNAME,
+                                         REG_SZ,
+                                         buffer.data,
+                                         buffer.length);
 
 
-       if (*lp_addprinter_cmd() &&
-                       (!strequal(printer->drivername, old_printer->drivername) ||
-                        !strequal(printer->comment, old_printer->comment) ||
-                        !strequal(printer->portname, old_printer->portname) ||
-                        !strequal(printer->location, old_printer->location)) )
-       {
-               /* add_printer_hook() will call reload_services() */
-               if (!add_printer_hook(p->mem_ctx, p->server_info->ptok,
-                                     printer) ) {
-                       result = WERR_ACCESS_DENIED;
-                       goto done;
+               if (!force_update) {
+                       notify_printer_printername(snum, p);
                }
        }
 
                }
        }
 
-       /*
-        * When a *new* driver is bound to a printer, the drivername is used to
-        * lookup previously saved driver initialization info, which is then
-        * bound to the printer, simulating what happens in the Windows arch.
-        */
-       if (!strequal(printer->drivername, old_printer->drivername)) {
-               DEBUG(10,("update_printer: changing driver [%s]!  Sending event!\n",
-                       printer->drivername));
+       if (force_update || !strequal(printer->portname, old_printer->portname)) {
+               push_reg_sz(mem_ctx, &buffer, printer->portname);
+               winreg_set_printer_dataex(mem_ctx,
+                                         server_info,
+                                         printer->sharename,
+                                         SPOOL_DSSPOOLER_KEY,
+                                         SPOOL_REG_PORTNAME,
+                                         REG_SZ,
+                                         buffer.data,
+                                         buffer.length);
 
 
-               notify_printer_driver(snum, printer->drivername);
+               if (!force_update) {
+                       notify_printer_port(snum, printer->portname);
+               }
        }
 
        }
 
-       /*
-        * flag which changes actually occured.  This is a small subset of
-        * all the possible changes.  We also have to update things in the
-        * DsSpooler key.
-        */
-       if (!strequal(printer->comment, old_printer->comment)) {
-               push_reg_sz(talloc_tos(), &buffer, printer->comment);
-               winreg_set_printer_dataex(p->mem_ctx,
-                                         p->server_info,
+       if (force_update || !strequal(printer->location, old_printer->location)) {
+               push_reg_sz(mem_ctx, &buffer, printer->location);
+               winreg_set_printer_dataex(mem_ctx,
+                                         server_info,
                                          printer->sharename,
                                          SPOOL_DSSPOOLER_KEY,
                                          printer->sharename,
                                          SPOOL_DSSPOOLER_KEY,
-                                         "description",
+                                         SPOOL_REG_LOCATION,
                                          REG_SZ,
                                          buffer.data,
                                          buffer.length);
 
                                          REG_SZ,
                                          buffer.data,
                                          buffer.length);
 
-               notify_printer_comment(snum, printer->comment);
+               if (!force_update) {
+                       notify_printer_location(snum, printer->location);
+               }
        }
 
        }
 
-       if (!strequal(printer->sharename, old_printer->sharename)) {
-               push_reg_sz(talloc_tos(), &buffer, printer->sharename);
-               winreg_set_printer_dataex(p->mem_ctx,
-                                         p->server_info,
+       if (force_update || !strequal(printer->sepfile, old_printer->sepfile)) {
+               push_reg_sz(mem_ctx, &buffer, printer->sepfile);
+               winreg_set_printer_dataex(mem_ctx,
+                                         server_info,
                                          printer->sharename,
                                          SPOOL_DSSPOOLER_KEY,
                                          printer->sharename,
                                          SPOOL_DSSPOOLER_KEY,
-                                         "shareName",
+                                         SPOOL_REG_PRINTSEPARATORFILE,
                                          REG_SZ,
                                          buffer.data,
                                          buffer.length);
 
                                          REG_SZ,
                                          buffer.data,
                                          buffer.length);
 
-               notify_printer_sharename(snum, printer->sharename);
+               if (!force_update) {
+                       notify_printer_location(snum, printer->location);
+               }
        }
 
        }
 
-       if (!strequal(printer->printername, old_printer->printername)) {
-               const char *pname;
-
-               if ( (pname = strchr_m( printer->printername+2, '\\' )) != NULL )
-                       pname++;
-               else
-                       pname = printer->printername;
-
-               push_reg_sz(talloc_tos(), &buffer, pname);
-               winreg_set_printer_dataex(p->mem_ctx,
-                                         p->server_info,
+       if (force_update || printer->starttime != old_printer->starttime) {
+               buffer = data_blob_talloc(mem_ctx, NULL, 4);
+               SIVAL(buffer.data, 0, printer->starttime);
+               winreg_set_printer_dataex(mem_ctx,
+                                         server_info,
                                          printer->sharename,
                                          SPOOL_DSSPOOLER_KEY,
                                          printer->sharename,
                                          SPOOL_DSSPOOLER_KEY,
-                                         "printerName",
-                                         REG_SZ,
+                                         SPOOL_REG_PRINTSTARTTIME,
+                                         REG_DWORD,
                                          buffer.data,
                                          buffer.length);
                                          buffer.data,
                                          buffer.length);
-
-               notify_printer_printername( snum, pname );
        }
 
        }
 
-       if (!strequal(printer->portname, old_printer->portname)) {
-               push_reg_sz(talloc_tos(), &buffer, printer->portname);
-               winreg_set_printer_dataex(p->mem_ctx,
-                                         p->server_info,
+       if (force_update || printer->untiltime != old_printer->untiltime) {
+               buffer = data_blob_talloc(mem_ctx, NULL, 4);
+               SIVAL(buffer.data, 0, printer->untiltime);
+               winreg_set_printer_dataex(mem_ctx,
+                                         server_info,
                                          printer->sharename,
                                          SPOOL_DSSPOOLER_KEY,
                                          printer->sharename,
                                          SPOOL_DSSPOOLER_KEY,
-                                         "portName",
-                                         REG_SZ,
+                                         SPOOL_REG_PRINTENDTIME,
+                                         REG_DWORD,
                                          buffer.data,
                                          buffer.length);
                                          buffer.data,
                                          buffer.length);
+       }
 
 
-               notify_printer_port(snum, printer->portname);
+       if (force_update || printer->priority != old_printer->priority) {
+               buffer = data_blob_talloc(mem_ctx, NULL, 4);
+               SIVAL(buffer.data, 0, printer->priority);
+               winreg_set_printer_dataex(mem_ctx,
+                                         server_info,
+                                         printer->sharename,
+                                         SPOOL_DSSPOOLER_KEY,
+                                         SPOOL_REG_PRIORITY,
+                                         REG_DWORD,
+                                         buffer.data,
+                                         buffer.length);
        }
 
        }
 
-       if (!strequal(printer->location, old_printer->location)) {
-               push_reg_sz(talloc_tos(), &buffer, printer->location);
-               winreg_set_printer_dataex(p->mem_ctx,
-                                         p->server_info,
+       if (force_update || printer->attributes != old_printer->attributes) {
+               buffer = data_blob_talloc(mem_ctx, NULL, 4);
+               SIVAL(buffer.data, 0, (printer->attributes &
+                                      PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS));
+               winreg_set_printer_dataex(mem_ctx,
+                                         server_info,
                                          printer->sharename,
                                          SPOOL_DSSPOOLER_KEY,
                                          printer->sharename,
                                          SPOOL_DSSPOOLER_KEY,
-                                         "location",
-                                         REG_SZ,
+                                         SPOOL_REG_PRINTKEEPPRINTEDJOBS,
+                                         REG_DWORD,
                                          buffer.data,
                                          buffer.length);
 
                                          buffer.data,
                                          buffer.length);
 
-               notify_printer_location(snum, printer->location);
+               switch (printer->attributes & 0x3) {
+                       case 0:
+                               spooling = SPOOL_REGVAL_PRINTWHILESPOOLING;
+                               break;
+                       case 1:
+                               spooling = SPOOL_REGVAL_PRINTAFTERSPOOLED;
+                               break;
+                       case 2:
+                               spooling = SPOOL_REGVAL_PRINTDIRECT;
+                               break;
+                       default:
+                               spooling = "unknown";
+               }
+               push_reg_sz(mem_ctx, &buffer, spooling);
+               winreg_set_printer_dataex(mem_ctx,
+                                         server_info,
+                                         printer->sharename,
+                                         SPOOL_DSSPOOLER_KEY,
+                                         SPOOL_REG_PRINTSPOOLING,
+                                         REG_SZ,
+                                         buffer.data,
+                                         buffer.length);
        }
 
        }
 
-       /* here we need to update some more DsSpooler keys */
-       /* uNCName, serverName, shortServerName */
-
-       push_reg_sz(talloc_tos(), &buffer, global_myname());
-       winreg_set_printer_dataex(p->mem_ctx,
-                                 p->server_info,
+       push_reg_sz(mem_ctx, &buffer, global_myname());
+       winreg_set_printer_dataex(mem_ctx,
+                                 server_info,
                                  printer->sharename,
                                  SPOOL_DSSPOOLER_KEY,
                                  printer->sharename,
                                  SPOOL_DSSPOOLER_KEY,
-                                 "serverName",
+                                 SPOOL_REG_SHORTSERVERNAME,
                                  REG_SZ,
                                  buffer.data,
                                  buffer.length);
                                  REG_SZ,
                                  buffer.data,
                                  buffer.length);
-       winreg_set_printer_dataex(p->mem_ctx,
-                                 p->server_info,
+
+       dnsdomname = get_mydnsfullname();
+       if (dnsdomname != NULL && dnsdomname[0] != '\0') {
+               longname = talloc_strdup(mem_ctx, dnsdomname);
+       } else {
+               longname = talloc_strdup(mem_ctx, global_myname());
+       }
+       if (longname == NULL) {
+               result = WERR_NOMEM;
+               goto done;
+       }
+
+       push_reg_sz(mem_ctx, &buffer, longname);
+       winreg_set_printer_dataex(mem_ctx,
+                                 server_info,
                                  printer->sharename,
                                  SPOOL_DSSPOOLER_KEY,
                                  printer->sharename,
                                  SPOOL_DSSPOOLER_KEY,
-                                 "shortServerName",
+                                 SPOOL_REG_SERVERNAME,
                                  REG_SZ,
                                  buffer.data,
                                  buffer.length);
 
                                  REG_SZ,
                                  buffer.data,
                                  buffer.length);
 
-       slprintf( asc_buffer, sizeof(asc_buffer)-1, "\\\\%s\\%s",
-                 global_myname(), printer->sharename );
-       push_reg_sz(talloc_tos(), &buffer, asc_buffer);
-       winreg_set_printer_dataex(p->mem_ctx,
-                                 p->server_info,
+       uncname = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
+                                 global_myname(), printer->sharename);
+       push_reg_sz(mem_ctx, &buffer, uncname);
+       winreg_set_printer_dataex(mem_ctx,
+                                 server_info,
                                  printer->sharename,
                                  SPOOL_DSSPOOLER_KEY,
                                  printer->sharename,
                                  SPOOL_DSSPOOLER_KEY,
-                                 "uNCName",
+                                 SPOOL_REG_UNCNAME,
                                  REG_SZ,
                                  buffer.data,
                                  buffer.length);
 
                                  REG_SZ,
                                  buffer.data,
                                  buffer.length);
 
+done:
+       return result;
+}
+
+/********************************************************************
+ * Called by spoolss_api_setprinter
+ * when updating a printer description.
+ ********************************************************************/
+
+static WERROR update_printer(struct pipes_struct *p,
+                            struct policy_handle *handle,
+                            struct spoolss_SetPrinterInfoCtr *info_ctr,
+                            struct spoolss_DeviceMode *devmode)
+{
+       uint32_t printer_mask = SPOOLSS_PRINTER_INFO_ALL;
+       struct spoolss_SetPrinterInfo2 *printer = info_ctr->info.info2;
+       struct spoolss_PrinterInfo2 *old_printer;
+       Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
+       const char *servername = NULL;
+       int snum;
+       WERROR result = WERR_OK;
+       TALLOC_CTX *tmp_ctx;
+
+       DEBUG(8,("update_printer\n"));
+
+       tmp_ctx = talloc_new(p->mem_ctx);
+       if (tmp_ctx == NULL) {
+               return WERR_NOMEM;
+       }
+
+       if (!Printer) {
+               result = WERR_BADFID;
+               goto done;
+       }
+
+       if (!get_printer_snum(p, handle, &snum, NULL)) {
+               result = WERR_BADFID;
+               goto done;
+       }
+
+       if (Printer != NULL || Printer->servername != NULL) {
+               servername = Printer->servername;
+       }
+
+       result = winreg_get_printer(tmp_ctx,
+                                   p->server_info,
+                                   servername,
+                                   lp_const_servicename(snum),
+                                   &old_printer);
+       if (!W_ERROR_IS_OK(result)) {
+               result = WERR_BADFID;
+               goto done;
+       }
+
+       /* Do sanity check on the requested changes for Samba */
+       if (!check_printer_ok(tmp_ctx, printer, snum)) {
+               result = WERR_INVALID_PARAM;
+               goto done;
+       }
+
+       /* FIXME!!! If the driver has changed we really should verify that
+          it is installed before doing much else   --jerry */
+
+       /* Check calling user has permission to update printer description */
+       if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
+               DEBUG(3, ("update_printer: printer property change denied by handle\n"));
+               result = WERR_ACCESS_DENIED;
+               goto done;
+       }
+
+       /* Call addprinter hook */
+       /* Check changes to see if this is really needed */
+
+       if (*lp_addprinter_cmd() &&
+                       (!strequal(printer->drivername, old_printer->drivername) ||
+                        !strequal(printer->comment, old_printer->comment) ||
+                        !strequal(printer->portname, old_printer->portname) ||
+                        !strequal(printer->location, old_printer->location)) )
+       {
+               /* add_printer_hook() will call reload_services() */
+               if (!add_printer_hook(tmp_ctx, p->server_info->ptok,
+                                     printer, p->client_address) ) {
+                       result = WERR_ACCESS_DENIED;
+                       goto done;
+               }
+       }
+
+       update_dsspooler(tmp_ctx,
+                        p->server_info,
+                        snum,
+                        printer,
+                        old_printer);
+
        printer_mask &= ~SPOOLSS_PRINTER_INFO_SECDESC;
 
        if (devmode == NULL) {
                printer_mask &= ~SPOOLSS_PRINTER_INFO_DEVMODE;
        }
        printer_mask &= ~SPOOLSS_PRINTER_INFO_SECDESC;
 
        if (devmode == NULL) {
                printer_mask &= ~SPOOLSS_PRINTER_INFO_DEVMODE;
        }
-       result = winreg_update_printer(p->mem_ctx,
+       result = winreg_update_printer(tmp_ctx,
                                       p->server_info,
                                       printer->sharename,
                                       printer_mask,
                                       p->server_info,
                                       printer->sharename,
                                       printer_mask,
@@ -5713,18 +5991,20 @@ static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
                                       NULL);
 
 done:
                                       NULL);
 
 done:
-       talloc_free(old_printer);
+       talloc_free(tmp_ctx);
 
        return result;
 }
 
 /****************************************************************************
 ****************************************************************************/
 
        return result;
 }
 
 /****************************************************************************
 ****************************************************************************/
-static WERROR publish_or_unpublish_printer(pipes_struct *p,
+static WERROR publish_or_unpublish_printer(struct pipes_struct *p,
                                           struct policy_handle *handle,
                                           struct spoolss_SetPrinterInfo7 *info7)
 {
 #ifdef HAVE_ADS
                                           struct policy_handle *handle,
                                           struct spoolss_SetPrinterInfo7 *info7)
 {
 #ifdef HAVE_ADS
+       struct spoolss_PrinterInfo2 *pinfo2 = NULL;
+       WERROR result;
        int snum;
        Printer_entry *Printer;
 
        int snum;
        Printer_entry *Printer;
 
@@ -5742,8 +6022,16 @@ static WERROR publish_or_unpublish_printer(pipes_struct *p,
        if (!get_printer_snum(p, handle, &snum, NULL))
                return WERR_BADFID;
 
        if (!get_printer_snum(p, handle, &snum, NULL))
                return WERR_BADFID;
 
-       nt_printer_publish(Printer, snum, info7->action);
+       result = winreg_get_printer(p->mem_ctx, p->server_info,
+                                   Printer->servername,
+                                   lp_servicename(snum), &pinfo2);
+       if (!W_ERROR_IS_OK(result)) {
+               return WERR_BADFID;
+       }
+
+       nt_printer_publish(pinfo2, p->server_info, pinfo2, info7->action);
 
 
+       TALLOC_FREE(pinfo2);
        return WERR_OK;
 #else
        return WERR_UNKNOWN_LEVEL;
        return WERR_OK;
 #else
        return WERR_UNKNOWN_LEVEL;
@@ -5753,7 +6041,8 @@ static WERROR publish_or_unpublish_printer(pipes_struct *p,
 /********************************************************************
  ********************************************************************/
 
 /********************************************************************
  ********************************************************************/
 
-static WERROR update_printer_devmode(pipes_struct *p, struct policy_handle *handle,
+static WERROR update_printer_devmode(struct pipes_struct *p,
+                                    struct policy_handle *handle,
                                     struct spoolss_DeviceMode *devmode)
 {
        int snum;
                                     struct spoolss_DeviceMode *devmode)
 {
        int snum;
@@ -5790,7 +6079,7 @@ static WERROR update_printer_devmode(pipes_struct *p, struct policy_handle *hand
  _spoolss_SetPrinter
 ****************************************************************/
 
  _spoolss_SetPrinter
 ****************************************************************/
 
-WERROR _spoolss_SetPrinter(pipes_struct *p,
+WERROR _spoolss_SetPrinter(struct pipes_struct *p,
                           struct spoolss_SetPrinter *r)
 {
        WERROR result;
                           struct spoolss_SetPrinter *r)
 {
        WERROR result;
@@ -5835,7 +6124,7 @@ WERROR _spoolss_SetPrinter(pipes_struct *p,
  _spoolss_FindClosePrinterNotify
 ****************************************************************/
 
  _spoolss_FindClosePrinterNotify
 ****************************************************************/
 
-WERROR _spoolss_FindClosePrinterNotify(pipes_struct *p,
+WERROR _spoolss_FindClosePrinterNotify(struct pipes_struct *p,
                                       struct spoolss_FindClosePrinterNotify *r)
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
                                       struct spoolss_FindClosePrinterNotify *r)
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
@@ -5872,7 +6161,7 @@ WERROR _spoolss_FindClosePrinterNotify(pipes_struct *p,
  _spoolss_AddJob
 ****************************************************************/
 
  _spoolss_AddJob
 ****************************************************************/
 
-WERROR _spoolss_AddJob(pipes_struct *p,
+WERROR _spoolss_AddJob(struct pipes_struct *p,
                       struct spoolss_AddJob *r)
 {
        if (!r->in.buffer && (r->in.offered != 0)) {
                       struct spoolss_AddJob *r)
 {
        if (!r->in.buffer && (r->in.offered != 0)) {
@@ -6072,12 +6361,13 @@ static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
        *count = num_queues;
 
        for (i=0; i<*count; i++) {
        *count = num_queues;
 
        for (i=0; i<*count; i++) {
-
                struct spoolss_DeviceMode *devmode;
 
                struct spoolss_DeviceMode *devmode;
 
-               devmode = construct_dev_mode(info, lp_const_servicename(snum));
-               if (!devmode) {
-                       result = WERR_NOMEM;
+               result = spoolss_create_default_devmode(info,
+                                                       pinfo2->printername,
+                                                       &devmode);
+               if (!W_ERROR_IS_OK(result)) {
+                       DEBUG(3, ("Can't proceed w/o a devmode!"));
                        goto out;
                }
 
                        goto out;
                }
 
@@ -6160,7 +6450,7 @@ static WERROR enumjobs_level3(TALLOC_CTX *mem_ctx,
  _spoolss_EnumJobs
 ****************************************************************/
 
  _spoolss_EnumJobs
 ****************************************************************/
 
-WERROR _spoolss_EnumJobs(pipes_struct *p,
+WERROR _spoolss_EnumJobs(struct pipes_struct *p,
                         struct spoolss_EnumJobs *r)
 {
        WERROR result;
                         struct spoolss_EnumJobs *r)
 {
        WERROR result;
@@ -6188,7 +6478,7 @@ WERROR _spoolss_EnumJobs(pipes_struct *p,
                return WERR_BADFID;
        }
 
                return WERR_BADFID;
        }
 
-       result = winreg_get_printer(talloc_tos(), p->server_info, NULL,
+       result = winreg_get_printer(p->mem_ctx, p->server_info, NULL,
                                    lp_servicename(snum), &pinfo2);
        if (!W_ERROR_IS_OK(result)) {
                return result;
                                    lp_servicename(snum), &pinfo2);
        if (!W_ERROR_IS_OK(result)) {
                return result;
@@ -6243,7 +6533,7 @@ WERROR _spoolss_EnumJobs(pipes_struct *p,
  _spoolss_ScheduleJob
 ****************************************************************/
 
  _spoolss_ScheduleJob
 ****************************************************************/
 
-WERROR _spoolss_ScheduleJob(pipes_struct *p,
+WERROR _spoolss_ScheduleJob(struct pipes_struct *p,
                            struct spoolss_ScheduleJob *r)
 {
        return WERR_OK;
                            struct spoolss_ScheduleJob *r)
 {
        return WERR_OK;
@@ -6278,7 +6568,7 @@ static WERROR spoolss_setjob_1(TALLOC_CTX *mem_ctx,
  _spoolss_SetJob
 ****************************************************************/
 
  _spoolss_SetJob
 ****************************************************************/
 
-WERROR _spoolss_SetJob(pipes_struct *p,
+WERROR _spoolss_SetJob(struct pipes_struct *p,
                       struct spoolss_SetJob *r)
 {
        int snum;
                       struct spoolss_SetJob *r)
 {
        int snum;
@@ -6295,7 +6585,9 @@ WERROR _spoolss_SetJob(pipes_struct *p,
        switch (r->in.command) {
        case SPOOLSS_JOB_CONTROL_CANCEL:
        case SPOOLSS_JOB_CONTROL_DELETE:
        switch (r->in.command) {
        case SPOOLSS_JOB_CONTROL_CANCEL:
        case SPOOLSS_JOB_CONTROL_DELETE:
-               if (print_job_delete(p->server_info, snum, r->in.job_id, &errcode)) {
+               errcode = print_job_delete(p->server_info,
+                                          snum, r->in.job_id);
+               if (W_ERROR_EQUAL(errcode, WERR_PRINTER_HAS_JOBS_QUEUED)) {
                        errcode = WERR_OK;
                }
                break;
                        errcode = WERR_OK;
                }
                break;
@@ -6512,7 +6804,7 @@ static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
  _spoolss_EnumPrinterDrivers
 ****************************************************************/
 
  _spoolss_EnumPrinterDrivers
 ****************************************************************/
 
-WERROR _spoolss_EnumPrinterDrivers(pipes_struct *p,
+WERROR _spoolss_EnumPrinterDrivers(struct pipes_struct *p,
                                   struct spoolss_EnumPrinterDrivers *r)
 {
        const char *cservername;
                                   struct spoolss_EnumPrinterDrivers *r)
 {
        const char *cservername;
@@ -6561,7 +6853,7 @@ WERROR _spoolss_EnumPrinterDrivers(pipes_struct *p,
  _spoolss_EnumForms
 ****************************************************************/
 
  _spoolss_EnumForms
 ****************************************************************/
 
-WERROR _spoolss_EnumForms(pipes_struct *p,
+WERROR _spoolss_EnumForms(struct pipes_struct *p,
                          struct spoolss_EnumForms *r)
 {
        WERROR result;
                          struct spoolss_EnumForms *r)
 {
        WERROR result;
@@ -6614,7 +6906,7 @@ WERROR _spoolss_EnumForms(pipes_struct *p,
  _spoolss_GetForm
 ****************************************************************/
 
  _spoolss_GetForm
 ****************************************************************/
 
-WERROR _spoolss_GetForm(pipes_struct *p,
+WERROR _spoolss_GetForm(struct pipes_struct *p,
                        struct spoolss_GetForm *r)
 {
        WERROR result;
                        struct spoolss_GetForm *r)
 {
        WERROR result;
@@ -6859,7 +7151,7 @@ out:
  _spoolss_EnumPorts
 ****************************************************************/
 
  _spoolss_EnumPorts
 ****************************************************************/
 
-WERROR _spoolss_EnumPorts(pipes_struct *p,
+WERROR _spoolss_EnumPorts(struct pipes_struct *p,
                          struct spoolss_EnumPorts *r)
 {
        WERROR result;
                          struct spoolss_EnumPorts *r)
 {
        WERROR result;
@@ -6906,7 +7198,7 @@ WERROR _spoolss_EnumPorts(pipes_struct *p,
 /****************************************************************************
 ****************************************************************************/
 
 /****************************************************************************
 ****************************************************************************/
 
-static WERROR spoolss_addprinterex_level_2(pipes_struct *p,
+static WERROR spoolss_addprinterex_level_2(struct pipes_struct *p,
                                           const char *server,
                                           struct spoolss_SetPrinterInfoCtr *info_ctr,
                                           struct spoolss_DeviceMode *devmode,
                                           const char *server,
                                           struct spoolss_SetPrinterInfoCtr *info_ctr,
                                           struct spoolss_DeviceMode *devmode,
@@ -6963,7 +7255,7 @@ static WERROR spoolss_addprinterex_level_2(pipes_struct *p,
 
        if (*lp_addprinter_cmd() ) {
                if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
 
        if (*lp_addprinter_cmd() ) {
                if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
-                                      info2) ) {
+                                      info2, p->client_address) ) {
                        return WERR_ACCESS_DENIED;
                }
        } else {
                        return WERR_ACCESS_DENIED;
                }
        } else {
@@ -6994,6 +7286,12 @@ static WERROR spoolss_addprinterex_level_2(pipes_struct *p,
                info2_mask = ~SPOOLSS_PRINTER_INFO_DEVMODE;
        }
 
                info2_mask = ~SPOOLSS_PRINTER_INFO_DEVMODE;
        }
 
+       update_dsspooler(p->mem_ctx,
+                        p->server_info,
+                        0,
+                        info2,
+                        NULL);
+
        err = winreg_update_printer(p->mem_ctx,
                                    p->server_info,
                                    info2->sharename,
        err = winreg_update_printer(p->mem_ctx,
                                    p->server_info,
                                    info2->sharename,
@@ -7018,7 +7316,7 @@ static WERROR spoolss_addprinterex_level_2(pipes_struct *p,
  _spoolss_AddPrinterEx
 ****************************************************************/
 
  _spoolss_AddPrinterEx
 ****************************************************************/
 
-WERROR _spoolss_AddPrinterEx(pipes_struct *p,
+WERROR _spoolss_AddPrinterEx(struct pipes_struct *p,
                             struct spoolss_AddPrinterEx *r)
 {
        switch (r->in.info_ctr->level) {
                             struct spoolss_AddPrinterEx *r)
 {
        switch (r->in.info_ctr->level) {
@@ -7042,7 +7340,7 @@ WERROR _spoolss_AddPrinterEx(pipes_struct *p,
  _spoolss_AddPrinter
 ****************************************************************/
 
  _spoolss_AddPrinter
 ****************************************************************/
 
-WERROR _spoolss_AddPrinter(pipes_struct *p,
+WERROR _spoolss_AddPrinter(struct pipes_struct *p,
                           struct spoolss_AddPrinter *r)
 {
        struct spoolss_AddPrinterEx a;
                           struct spoolss_AddPrinter *r)
 {
        struct spoolss_AddPrinterEx a;
@@ -7066,7 +7364,7 @@ WERROR _spoolss_AddPrinter(pipes_struct *p,
  _spoolss_AddPrinterDriverEx
 ****************************************************************/
 
  _spoolss_AddPrinterDriverEx
 ****************************************************************/
 
-WERROR _spoolss_AddPrinterDriverEx(pipes_struct *p,
+WERROR _spoolss_AddPrinterDriverEx(struct pipes_struct *p,
                                   struct spoolss_AddPrinterDriverEx *r)
 {
        WERROR err = WERR_OK;
                                   struct spoolss_AddPrinterDriverEx *r)
 {
        WERROR err = WERR_OK;
@@ -7145,7 +7443,7 @@ done:
  _spoolss_AddPrinterDriver
 ****************************************************************/
 
  _spoolss_AddPrinterDriver
 ****************************************************************/
 
-WERROR _spoolss_AddPrinterDriver(pipes_struct *p,
+WERROR _spoolss_AddPrinterDriver(struct pipes_struct *p,
                                 struct spoolss_AddPrinterDriver *r)
 {
        struct spoolss_AddPrinterDriverEx a;
                                 struct spoolss_AddPrinterDriver *r)
 {
        struct spoolss_AddPrinterDriverEx a;
@@ -7271,7 +7569,7 @@ static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
  _spoolss_GetPrinterDriverDirectory
 ****************************************************************/
 
  _spoolss_GetPrinterDriverDirectory
 ****************************************************************/
 
-WERROR _spoolss_GetPrinterDriverDirectory(pipes_struct *p,
+WERROR _spoolss_GetPrinterDriverDirectory(struct pipes_struct *p,
                                          struct spoolss_GetPrinterDriverDirectory *r)
 {
        WERROR werror;
                                          struct spoolss_GetPrinterDriverDirectory *r)
 {
        WERROR werror;
@@ -7309,7 +7607,7 @@ WERROR _spoolss_GetPrinterDriverDirectory(pipes_struct *p,
  _spoolss_EnumPrinterData
 ****************************************************************/
 
  _spoolss_EnumPrinterData
 ****************************************************************/
 
-WERROR _spoolss_EnumPrinterData(pipes_struct *p,
+WERROR _spoolss_EnumPrinterData(struct pipes_struct *p,
                                struct spoolss_EnumPrinterData *r)
 {
        WERROR result;
                                struct spoolss_EnumPrinterData *r)
 {
        WERROR result;
@@ -7449,7 +7747,7 @@ WERROR _spoolss_EnumPrinterData(pipes_struct *p,
  _spoolss_SetPrinterData
 ****************************************************************/
 
  _spoolss_SetPrinterData
 ****************************************************************/
 
-WERROR _spoolss_SetPrinterData(pipes_struct *p,
+WERROR _spoolss_SetPrinterData(struct pipes_struct *p,
                               struct spoolss_SetPrinterData *r)
 {
        struct spoolss_SetPrinterDataEx r2;
                               struct spoolss_SetPrinterData *r)
 {
        struct spoolss_SetPrinterDataEx r2;
@@ -7468,7 +7766,7 @@ WERROR _spoolss_SetPrinterData(pipes_struct *p,
  _spoolss_ResetPrinter
 ****************************************************************/
 
  _spoolss_ResetPrinter
 ****************************************************************/
 
-WERROR _spoolss_ResetPrinter(pipes_struct *p,
+WERROR _spoolss_ResetPrinter(struct pipes_struct *p,
                             struct spoolss_ResetPrinter *r)
 {
        Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
                             struct spoolss_ResetPrinter *r)
 {
        Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
@@ -7500,7 +7798,7 @@ WERROR _spoolss_ResetPrinter(pipes_struct *p,
  _spoolss_DeletePrinterData
 ****************************************************************/
 
  _spoolss_DeletePrinterData
 ****************************************************************/
 
-WERROR _spoolss_DeletePrinterData(pipes_struct *p,
+WERROR _spoolss_DeletePrinterData(struct pipes_struct *p,
                                  struct spoolss_DeletePrinterData *r)
 {
        struct spoolss_DeletePrinterDataEx r2;
                                  struct spoolss_DeletePrinterData *r)
 {
        struct spoolss_DeletePrinterDataEx r2;
@@ -7516,7 +7814,7 @@ WERROR _spoolss_DeletePrinterData(pipes_struct *p,
  _spoolss_AddForm
 ****************************************************************/
 
  _spoolss_AddForm
 ****************************************************************/
 
-WERROR _spoolss_AddForm(pipes_struct *p,
+WERROR _spoolss_AddForm(struct pipes_struct *p,
                        struct spoolss_AddForm *r)
 {
        struct spoolss_AddFormInfo1 *form = r->in.info.info1;
                        struct spoolss_AddForm *r)
 {
        struct spoolss_AddFormInfo1 *form = r->in.info.info1;
@@ -7585,7 +7883,7 @@ WERROR _spoolss_AddForm(pipes_struct *p,
  _spoolss_DeleteForm
 ****************************************************************/
 
  _spoolss_DeleteForm
 ****************************************************************/
 
-WERROR _spoolss_DeleteForm(pipes_struct *p,
+WERROR _spoolss_DeleteForm(struct pipes_struct *p,
                           struct spoolss_DeleteForm *r)
 {
        const char *form_name = r->in.form_name;
                           struct spoolss_DeleteForm *r)
 {
        const char *form_name = r->in.form_name;
@@ -7643,7 +7941,7 @@ WERROR _spoolss_DeleteForm(pipes_struct *p,
  _spoolss_SetForm
 ****************************************************************/
 
  _spoolss_SetForm
 ****************************************************************/
 
-WERROR _spoolss_SetForm(pipes_struct *p,
+WERROR _spoolss_SetForm(struct pipes_struct *p,
                        struct spoolss_SetForm *r)
 {
        struct spoolss_AddFormInfo1 *form = r->in.info.info1;
                        struct spoolss_SetForm *r)
 {
        struct spoolss_AddFormInfo1 *form = r->in.info.info1;
@@ -7754,7 +8052,7 @@ static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
  _spoolss_EnumPrintProcessors
 ****************************************************************/
 
  _spoolss_EnumPrintProcessors
 ****************************************************************/
 
-WERROR _spoolss_EnumPrintProcessors(pipes_struct *p,
+WERROR _spoolss_EnumPrintProcessors(struct pipes_struct *p,
                                    struct spoolss_EnumPrintProcessors *r)
 {
        WERROR result;
                                    struct spoolss_EnumPrintProcessors *r)
 {
        WERROR result;
@@ -7852,7 +8150,7 @@ static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
  _spoolss_EnumPrintProcDataTypes
 ****************************************************************/
 
  _spoolss_EnumPrintProcDataTypes
 ****************************************************************/
 
-WERROR _spoolss_EnumPrintProcDataTypes(pipes_struct *p,
+WERROR _spoolss_EnumPrintProcDataTypes(struct pipes_struct *p,
                                       struct spoolss_EnumPrintProcDataTypes *r)
 {
        WERROR result;
                                       struct spoolss_EnumPrintProcDataTypes *r)
 {
        WERROR result;
@@ -8010,7 +8308,7 @@ out:
  _spoolss_EnumMonitors
 ****************************************************************/
 
  _spoolss_EnumMonitors
 ****************************************************************/
 
-WERROR _spoolss_EnumMonitors(pipes_struct *p,
+WERROR _spoolss_EnumMonitors(struct pipes_struct *p,
                             struct spoolss_EnumMonitors *r)
 {
        WERROR result;
                             struct spoolss_EnumMonitors *r)
 {
        WERROR result;
@@ -8107,6 +8405,7 @@ static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
        int i = 0;
        bool found = false;
        struct spoolss_DeviceMode *devmode;
        int i = 0;
        bool found = false;
        struct spoolss_DeviceMode *devmode;
+       WERROR result;
 
        for (i=0; i<count; i++) {
                if (queue[i].job == (int)jobid) {
 
        for (i=0; i<count; i++) {
                if (queue[i].job == (int)jobid) {
@@ -8129,8 +8428,13 @@ static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
 
        devmode = print_job_devmode(lp_const_servicename(snum), jobid);
        if (!devmode) {
 
        devmode = print_job_devmode(lp_const_servicename(snum), jobid);
        if (!devmode) {
-               devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
-               W_ERROR_HAVE_NO_MEMORY(devmode);
+               result = spoolss_create_default_devmode(mem_ctx,
+                                               pinfo2->printername,
+                                               &devmode);
+               if (!W_ERROR_IS_OK(result)) {
+                       DEBUG(3, ("Can't proceed w/o a devmode!"));
+                       return result;
+               }
        }
 
        return fill_job_info2(mem_ctx,
        }
 
        return fill_job_info2(mem_ctx,
@@ -8146,7 +8450,7 @@ static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
  _spoolss_GetJob
 ****************************************************************/
 
  _spoolss_GetJob
 ****************************************************************/
 
-WERROR _spoolss_GetJob(pipes_struct *p,
+WERROR _spoolss_GetJob(struct pipes_struct *p,
                       struct spoolss_GetJob *r)
 {
        WERROR result = WERR_OK;
                       struct spoolss_GetJob *r)
 {
        WERROR result = WERR_OK;
@@ -8170,7 +8474,7 @@ WERROR _spoolss_GetJob(pipes_struct *p,
                return WERR_BADFID;
        }
 
                return WERR_BADFID;
        }
 
-       result = winreg_get_printer(talloc_tos(), p->server_info, NULL,
+       result = winreg_get_printer(p->mem_ctx, p->server_info, NULL,
                                    lp_servicename(snum), &pinfo2);
        if (!W_ERROR_IS_OK(result)) {
                return result;
                                    lp_servicename(snum), &pinfo2);
        if (!W_ERROR_IS_OK(result)) {
                return result;
@@ -8216,7 +8520,7 @@ WERROR _spoolss_GetJob(pipes_struct *p,
  _spoolss_GetPrinterDataEx
 ****************************************************************/
 
  _spoolss_GetPrinterDataEx
 ****************************************************************/
 
-WERROR _spoolss_GetPrinterDataEx(pipes_struct *p,
+WERROR _spoolss_GetPrinterDataEx(struct pipes_struct *p,
                                 struct spoolss_GetPrinterDataEx *r)
 {
 
                                 struct spoolss_GetPrinterDataEx *r)
 {
 
@@ -8338,7 +8642,7 @@ WERROR _spoolss_GetPrinterDataEx(pipes_struct *p,
  _spoolss_SetPrinterDataEx
 ****************************************************************/
 
  _spoolss_SetPrinterDataEx
 ****************************************************************/
 
-WERROR _spoolss_SetPrinterDataEx(pipes_struct *p,
+WERROR _spoolss_SetPrinterDataEx(struct pipes_struct *p,
                                 struct spoolss_SetPrinterDataEx *r)
 {
        struct spoolss_PrinterInfo2 *pinfo2 = NULL;
                                 struct spoolss_SetPrinterDataEx *r)
 {
        struct spoolss_PrinterInfo2 *pinfo2 = NULL;
@@ -8450,7 +8754,7 @@ done:
  _spoolss_DeletePrinterDataEx
 ****************************************************************/
 
  _spoolss_DeletePrinterDataEx
 ****************************************************************/
 
-WERROR _spoolss_DeletePrinterDataEx(pipes_struct *p,
+WERROR _spoolss_DeletePrinterDataEx(struct pipes_struct *p,
                                    struct spoolss_DeletePrinterDataEx *r)
 {
        const char *printer;
                                    struct spoolss_DeletePrinterDataEx *r)
 {
        const char *printer;
@@ -8500,7 +8804,7 @@ WERROR _spoolss_DeletePrinterDataEx(pipes_struct *p,
  _spoolss_EnumPrinterKey
 ****************************************************************/
 
  _spoolss_EnumPrinterKey
 ****************************************************************/
 
-WERROR _spoolss_EnumPrinterKey(pipes_struct *p,
+WERROR _spoolss_EnumPrinterKey(struct pipes_struct *p,
                               struct spoolss_EnumPrinterKey *r)
 {
        uint32_t        num_keys;
                               struct spoolss_EnumPrinterKey *r)
 {
        uint32_t        num_keys;
@@ -8562,7 +8866,7 @@ WERROR _spoolss_EnumPrinterKey(pipes_struct *p,
  _spoolss_DeletePrinterKey
 ****************************************************************/
 
  _spoolss_DeletePrinterKey
 ****************************************************************/
 
-WERROR _spoolss_DeletePrinterKey(pipes_struct *p,
+WERROR _spoolss_DeletePrinterKey(struct pipes_struct *p,
                                 struct spoolss_DeletePrinterKey *r)
 {
        Printer_entry           *Printer = find_printer_index_by_hnd(p, r->in.handle);
                                 struct spoolss_DeletePrinterKey *r)
 {
        Printer_entry           *Printer = find_printer_index_by_hnd(p, r->in.handle);
@@ -8612,7 +8916,7 @@ WERROR _spoolss_DeletePrinterKey(pipes_struct *p,
  _spoolss_EnumPrinterDataEx
 ****************************************************************/
 
  _spoolss_EnumPrinterDataEx
 ****************************************************************/
 
-WERROR _spoolss_EnumPrinterDataEx(pipes_struct *p,
+WERROR _spoolss_EnumPrinterDataEx(struct pipes_struct *p,
                                  struct spoolss_EnumPrinterDataEx *r)
 {
        uint32_t        count = 0;
                                  struct spoolss_EnumPrinterDataEx *r)
 {
        uint32_t        count = 0;
@@ -8721,7 +9025,7 @@ static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
  _spoolss_GetPrintProcessorDirectory
 ****************************************************************/
 
  _spoolss_GetPrintProcessorDirectory
 ****************************************************************/
 
-WERROR _spoolss_GetPrintProcessorDirectory(pipes_struct *p,
+WERROR _spoolss_GetPrintProcessorDirectory(struct pipes_struct *p,
                                           struct spoolss_GetPrintProcessorDirectory *r)
 {
        WERROR result;
                                           struct spoolss_GetPrintProcessorDirectory *r)
 {
        WERROR result;
@@ -9008,7 +9312,7 @@ static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
  _spoolss_XcvData
 ****************************************************************/
 
  _spoolss_XcvData
 ****************************************************************/
 
-WERROR _spoolss_XcvData(pipes_struct *p,
+WERROR _spoolss_XcvData(struct pipes_struct *p,
                        struct spoolss_XcvData *r)
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
                        struct spoolss_XcvData *r)
 {
        Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
@@ -9081,7 +9385,7 @@ WERROR _spoolss_XcvData(pipes_struct *p,
  _spoolss_AddPrintProcessor
 ****************************************************************/
 
  _spoolss_AddPrintProcessor
 ****************************************************************/
 
-WERROR _spoolss_AddPrintProcessor(pipes_struct *p,
+WERROR _spoolss_AddPrintProcessor(struct pipes_struct *p,
                                  struct spoolss_AddPrintProcessor *r)
 {
        /* for now, just indicate success and ignore the add.  We'll
                                  struct spoolss_AddPrintProcessor *r)
 {
        /* for now, just indicate success and ignore the add.  We'll
@@ -9096,7 +9400,7 @@ WERROR _spoolss_AddPrintProcessor(pipes_struct *p,
  _spoolss_AddPort
 ****************************************************************/
 
  _spoolss_AddPort
 ****************************************************************/
 
-WERROR _spoolss_AddPort(pipes_struct *p,
+WERROR _spoolss_AddPort(struct pipes_struct *p,
                        struct spoolss_AddPort *r)
 {
        /* do what w2k3 does */
                        struct spoolss_AddPort *r)
 {
        /* do what w2k3 does */
@@ -9108,7 +9412,7 @@ WERROR _spoolss_AddPort(pipes_struct *p,
  _spoolss_GetPrinterDriver
 ****************************************************************/
 
  _spoolss_GetPrinterDriver
 ****************************************************************/
 
-WERROR _spoolss_GetPrinterDriver(pipes_struct *p,
+WERROR _spoolss_GetPrinterDriver(struct pipes_struct *p,
                                 struct spoolss_GetPrinterDriver *r)
 {
        p->rng_fault_state = true;
                                 struct spoolss_GetPrinterDriver *r)
 {
        p->rng_fault_state = true;
@@ -9119,7 +9423,7 @@ WERROR _spoolss_GetPrinterDriver(pipes_struct *p,
  _spoolss_ReadPrinter
 ****************************************************************/
 
  _spoolss_ReadPrinter
 ****************************************************************/
 
-WERROR _spoolss_ReadPrinter(pipes_struct *p,
+WERROR _spoolss_ReadPrinter(struct pipes_struct *p,
                            struct spoolss_ReadPrinter *r)
 {
        p->rng_fault_state = true;
                            struct spoolss_ReadPrinter *r)
 {
        p->rng_fault_state = true;
@@ -9130,7 +9434,7 @@ WERROR _spoolss_ReadPrinter(pipes_struct *p,
  _spoolss_WaitForPrinterChange
 ****************************************************************/
 
  _spoolss_WaitForPrinterChange
 ****************************************************************/
 
-WERROR _spoolss_WaitForPrinterChange(pipes_struct *p,
+WERROR _spoolss_WaitForPrinterChange(struct pipes_struct *p,
                                     struct spoolss_WaitForPrinterChange *r)
 {
        p->rng_fault_state = true;
                                     struct spoolss_WaitForPrinterChange *r)
 {
        p->rng_fault_state = true;
@@ -9141,7 +9445,7 @@ WERROR _spoolss_WaitForPrinterChange(pipes_struct *p,
  _spoolss_ConfigurePort
 ****************************************************************/
 
  _spoolss_ConfigurePort
 ****************************************************************/
 
-WERROR _spoolss_ConfigurePort(pipes_struct *p,
+WERROR _spoolss_ConfigurePort(struct pipes_struct *p,
                              struct spoolss_ConfigurePort *r)
 {
        p->rng_fault_state = true;
                              struct spoolss_ConfigurePort *r)
 {
        p->rng_fault_state = true;
@@ -9152,7 +9456,7 @@ WERROR _spoolss_ConfigurePort(pipes_struct *p,
  _spoolss_DeletePort
 ****************************************************************/
 
  _spoolss_DeletePort
 ****************************************************************/
 
-WERROR _spoolss_DeletePort(pipes_struct *p,
+WERROR _spoolss_DeletePort(struct pipes_struct *p,
                           struct spoolss_DeletePort *r)
 {
        p->rng_fault_state = true;
                           struct spoolss_DeletePort *r)
 {
        p->rng_fault_state = true;
@@ -9163,7 +9467,7 @@ WERROR _spoolss_DeletePort(pipes_struct *p,
  _spoolss_CreatePrinterIC
 ****************************************************************/
 
  _spoolss_CreatePrinterIC
 ****************************************************************/
 
-WERROR _spoolss_CreatePrinterIC(pipes_struct *p,
+WERROR _spoolss_CreatePrinterIC(struct pipes_struct *p,
                                struct spoolss_CreatePrinterIC *r)
 {
        p->rng_fault_state = true;
                                struct spoolss_CreatePrinterIC *r)
 {
        p->rng_fault_state = true;
@@ -9174,7 +9478,7 @@ WERROR _spoolss_CreatePrinterIC(pipes_struct *p,
  _spoolss_PlayGDIScriptOnPrinterIC
 ****************************************************************/
 
  _spoolss_PlayGDIScriptOnPrinterIC
 ****************************************************************/
 
-WERROR _spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p,
+WERROR _spoolss_PlayGDIScriptOnPrinterIC(struct pipes_struct *p,
                                         struct spoolss_PlayGDIScriptOnPrinterIC *r)
 {
        p->rng_fault_state = true;
                                         struct spoolss_PlayGDIScriptOnPrinterIC *r)
 {
        p->rng_fault_state = true;
@@ -9185,7 +9489,7 @@ WERROR _spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p,
  _spoolss_DeletePrinterIC
 ****************************************************************/
 
  _spoolss_DeletePrinterIC
 ****************************************************************/
 
-WERROR _spoolss_DeletePrinterIC(pipes_struct *p,
+WERROR _spoolss_DeletePrinterIC(struct pipes_struct *p,
                                struct spoolss_DeletePrinterIC *r)
 {
        p->rng_fault_state = true;
                                struct spoolss_DeletePrinterIC *r)
 {
        p->rng_fault_state = true;
@@ -9196,7 +9500,7 @@ WERROR _spoolss_DeletePrinterIC(pipes_struct *p,
  _spoolss_AddPrinterConnection
 ****************************************************************/
 
  _spoolss_AddPrinterConnection
 ****************************************************************/
 
-WERROR _spoolss_AddPrinterConnection(pipes_struct *p,
+WERROR _spoolss_AddPrinterConnection(struct pipes_struct *p,
                                     struct spoolss_AddPrinterConnection *r)
 {
        p->rng_fault_state = true;
                                     struct spoolss_AddPrinterConnection *r)
 {
        p->rng_fault_state = true;
@@ -9207,7 +9511,7 @@ WERROR _spoolss_AddPrinterConnection(pipes_struct *p,
  _spoolss_DeletePrinterConnection
 ****************************************************************/
 
  _spoolss_DeletePrinterConnection
 ****************************************************************/
 
-WERROR _spoolss_DeletePrinterConnection(pipes_struct *p,
+WERROR _spoolss_DeletePrinterConnection(struct pipes_struct *p,
                                        struct spoolss_DeletePrinterConnection *r)
 {
        p->rng_fault_state = true;
                                        struct spoolss_DeletePrinterConnection *r)
 {
        p->rng_fault_state = true;
@@ -9218,7 +9522,7 @@ WERROR _spoolss_DeletePrinterConnection(pipes_struct *p,
  _spoolss_PrinterMessageBox
 ****************************************************************/
 
  _spoolss_PrinterMessageBox
 ****************************************************************/
 
-WERROR _spoolss_PrinterMessageBox(pipes_struct *p,
+WERROR _spoolss_PrinterMessageBox(struct pipes_struct *p,
                                  struct spoolss_PrinterMessageBox *r)
 {
        p->rng_fault_state = true;
                                  struct spoolss_PrinterMessageBox *r)
 {
        p->rng_fault_state = true;
@@ -9229,7 +9533,7 @@ WERROR _spoolss_PrinterMessageBox(pipes_struct *p,
  _spoolss_AddMonitor
 ****************************************************************/
 
  _spoolss_AddMonitor
 ****************************************************************/
 
-WERROR _spoolss_AddMonitor(pipes_struct *p,
+WERROR _spoolss_AddMonitor(struct pipes_struct *p,
                           struct spoolss_AddMonitor *r)
 {
        p->rng_fault_state = true;
                           struct spoolss_AddMonitor *r)
 {
        p->rng_fault_state = true;
@@ -9240,7 +9544,7 @@ WERROR _spoolss_AddMonitor(pipes_struct *p,
  _spoolss_DeleteMonitor
 ****************************************************************/
 
  _spoolss_DeleteMonitor
 ****************************************************************/
 
-WERROR _spoolss_DeleteMonitor(pipes_struct *p,
+WERROR _spoolss_DeleteMonitor(struct pipes_struct *p,
                              struct spoolss_DeleteMonitor *r)
 {
        p->rng_fault_state = true;
                              struct spoolss_DeleteMonitor *r)
 {
        p->rng_fault_state = true;
@@ -9251,7 +9555,7 @@ WERROR _spoolss_DeleteMonitor(pipes_struct *p,
  _spoolss_DeletePrintProcessor
 ****************************************************************/
 
  _spoolss_DeletePrintProcessor
 ****************************************************************/
 
-WERROR _spoolss_DeletePrintProcessor(pipes_struct *p,
+WERROR _spoolss_DeletePrintProcessor(struct pipes_struct *p,
                                     struct spoolss_DeletePrintProcessor *r)
 {
        p->rng_fault_state = true;
                                     struct spoolss_DeletePrintProcessor *r)
 {
        p->rng_fault_state = true;
@@ -9262,7 +9566,7 @@ WERROR _spoolss_DeletePrintProcessor(pipes_struct *p,
  _spoolss_AddPrintProvidor
 ****************************************************************/
 
  _spoolss_AddPrintProvidor
 ****************************************************************/
 
-WERROR _spoolss_AddPrintProvidor(pipes_struct *p,
+WERROR _spoolss_AddPrintProvidor(struct pipes_struct *p,
                                 struct spoolss_AddPrintProvidor *r)
 {
        p->rng_fault_state = true;
                                 struct spoolss_AddPrintProvidor *r)
 {
        p->rng_fault_state = true;
@@ -9273,7 +9577,7 @@ WERROR _spoolss_AddPrintProvidor(pipes_struct *p,
  _spoolss_DeletePrintProvidor
 ****************************************************************/
 
  _spoolss_DeletePrintProvidor
 ****************************************************************/
 
-WERROR _spoolss_DeletePrintProvidor(pipes_struct *p,
+WERROR _spoolss_DeletePrintProvidor(struct pipes_struct *p,
                                    struct spoolss_DeletePrintProvidor *r)
 {
        p->rng_fault_state = true;
                                    struct spoolss_DeletePrintProvidor *r)
 {
        p->rng_fault_state = true;
@@ -9284,7 +9588,7 @@ WERROR _spoolss_DeletePrintProvidor(pipes_struct *p,
  _spoolss_FindFirstPrinterChangeNotification
 ****************************************************************/
 
  _spoolss_FindFirstPrinterChangeNotification
 ****************************************************************/
 
-WERROR _spoolss_FindFirstPrinterChangeNotification(pipes_struct *p,
+WERROR _spoolss_FindFirstPrinterChangeNotification(struct pipes_struct *p,
                                                   struct spoolss_FindFirstPrinterChangeNotification *r)
 {
        p->rng_fault_state = true;
                                                   struct spoolss_FindFirstPrinterChangeNotification *r)
 {
        p->rng_fault_state = true;
@@ -9295,7 +9599,7 @@ WERROR _spoolss_FindFirstPrinterChangeNotification(pipes_struct *p,
  _spoolss_FindNextPrinterChangeNotification
 ****************************************************************/
 
  _spoolss_FindNextPrinterChangeNotification
 ****************************************************************/
 
-WERROR _spoolss_FindNextPrinterChangeNotification(pipes_struct *p,
+WERROR _spoolss_FindNextPrinterChangeNotification(struct pipes_struct *p,
                                                  struct spoolss_FindNextPrinterChangeNotification *r)
 {
        p->rng_fault_state = true;
                                                  struct spoolss_FindNextPrinterChangeNotification *r)
 {
        p->rng_fault_state = true;
@@ -9306,7 +9610,7 @@ WERROR _spoolss_FindNextPrinterChangeNotification(pipes_struct *p,
  _spoolss_RouterFindFirstPrinterChangeNotificationOld
 ****************************************************************/
 
  _spoolss_RouterFindFirstPrinterChangeNotificationOld
 ****************************************************************/
 
-WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p,
+WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(struct pipes_struct *p,
                                                            struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
 {
        p->rng_fault_state = true;
                                                            struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
 {
        p->rng_fault_state = true;
@@ -9317,7 +9621,7 @@ WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p,
  _spoolss_ReplyOpenPrinter
 ****************************************************************/
 
  _spoolss_ReplyOpenPrinter
 ****************************************************************/
 
-WERROR _spoolss_ReplyOpenPrinter(pipes_struct *p,
+WERROR _spoolss_ReplyOpenPrinter(struct pipes_struct *p,
                                 struct spoolss_ReplyOpenPrinter *r)
 {
        p->rng_fault_state = true;
                                 struct spoolss_ReplyOpenPrinter *r)
 {
        p->rng_fault_state = true;
@@ -9328,7 +9632,7 @@ WERROR _spoolss_ReplyOpenPrinter(pipes_struct *p,
  _spoolss_RouterReplyPrinter
 ****************************************************************/
 
  _spoolss_RouterReplyPrinter
 ****************************************************************/
 
-WERROR _spoolss_RouterReplyPrinter(pipes_struct *p,
+WERROR _spoolss_RouterReplyPrinter(struct pipes_struct *p,
                                   struct spoolss_RouterReplyPrinter *r)
 {
        p->rng_fault_state = true;
                                   struct spoolss_RouterReplyPrinter *r)
 {
        p->rng_fault_state = true;
@@ -9339,7 +9643,7 @@ WERROR _spoolss_RouterReplyPrinter(pipes_struct *p,
  _spoolss_ReplyClosePrinter
 ****************************************************************/
 
  _spoolss_ReplyClosePrinter
 ****************************************************************/
 
-WERROR _spoolss_ReplyClosePrinter(pipes_struct *p,
+WERROR _spoolss_ReplyClosePrinter(struct pipes_struct *p,
                                  struct spoolss_ReplyClosePrinter *r)
 {
        p->rng_fault_state = true;
                                  struct spoolss_ReplyClosePrinter *r)
 {
        p->rng_fault_state = true;
@@ -9350,7 +9654,7 @@ WERROR _spoolss_ReplyClosePrinter(pipes_struct *p,
  _spoolss_AddPortEx
 ****************************************************************/
 
  _spoolss_AddPortEx
 ****************************************************************/
 
-WERROR _spoolss_AddPortEx(pipes_struct *p,
+WERROR _spoolss_AddPortEx(struct pipes_struct *p,
                          struct spoolss_AddPortEx *r)
 {
        p->rng_fault_state = true;
                          struct spoolss_AddPortEx *r)
 {
        p->rng_fault_state = true;
@@ -9361,7 +9665,7 @@ WERROR _spoolss_AddPortEx(pipes_struct *p,
  _spoolss_RouterFindFirstPrinterChangeNotification
 ****************************************************************/
 
  _spoolss_RouterFindFirstPrinterChangeNotification
 ****************************************************************/
 
-WERROR _spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p,
+WERROR _spoolss_RouterFindFirstPrinterChangeNotification(struct pipes_struct *p,
                                                         struct spoolss_RouterFindFirstPrinterChangeNotification *r)
 {
        p->rng_fault_state = true;
                                                         struct spoolss_RouterFindFirstPrinterChangeNotification *r)
 {
        p->rng_fault_state = true;
@@ -9372,7 +9676,7 @@ WERROR _spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p,
  _spoolss_SpoolerInit
 ****************************************************************/
 
  _spoolss_SpoolerInit
 ****************************************************************/
 
-WERROR _spoolss_SpoolerInit(pipes_struct *p,
+WERROR _spoolss_SpoolerInit(struct pipes_struct *p,
                            struct spoolss_SpoolerInit *r)
 {
        p->rng_fault_state = true;
                            struct spoolss_SpoolerInit *r)
 {
        p->rng_fault_state = true;
@@ -9383,7 +9687,7 @@ WERROR _spoolss_SpoolerInit(pipes_struct *p,
  _spoolss_ResetPrinterEx
 ****************************************************************/
 
  _spoolss_ResetPrinterEx
 ****************************************************************/
 
-WERROR _spoolss_ResetPrinterEx(pipes_struct *p,
+WERROR _spoolss_ResetPrinterEx(struct pipes_struct *p,
                               struct spoolss_ResetPrinterEx *r)
 {
        p->rng_fault_state = true;
                               struct spoolss_ResetPrinterEx *r)
 {
        p->rng_fault_state = true;
@@ -9394,7 +9698,7 @@ WERROR _spoolss_ResetPrinterEx(pipes_struct *p,
  _spoolss_RouterReplyPrinterEx
 ****************************************************************/
 
  _spoolss_RouterReplyPrinterEx
 ****************************************************************/
 
-WERROR _spoolss_RouterReplyPrinterEx(pipes_struct *p,
+WERROR _spoolss_RouterReplyPrinterEx(struct pipes_struct *p,
                                     struct spoolss_RouterReplyPrinterEx *r)
 {
        p->rng_fault_state = true;
                                     struct spoolss_RouterReplyPrinterEx *r)
 {
        p->rng_fault_state = true;
@@ -9405,7 +9709,7 @@ WERROR _spoolss_RouterReplyPrinterEx(pipes_struct *p,
  _spoolss_44
 ****************************************************************/
 
  _spoolss_44
 ****************************************************************/
 
-WERROR _spoolss_44(pipes_struct *p,
+WERROR _spoolss_44(struct pipes_struct *p,
                   struct spoolss_44 *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_44 *r)
 {
        p->rng_fault_state = true;
@@ -9416,7 +9720,7 @@ WERROR _spoolss_44(pipes_struct *p,
  _spoolss_47
 ****************************************************************/
 
  _spoolss_47
 ****************************************************************/
 
-WERROR _spoolss_47(pipes_struct *p,
+WERROR _spoolss_47(struct pipes_struct *p,
                   struct spoolss_47 *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_47 *r)
 {
        p->rng_fault_state = true;
@@ -9427,7 +9731,7 @@ WERROR _spoolss_47(pipes_struct *p,
  _spoolss_4a
 ****************************************************************/
 
  _spoolss_4a
 ****************************************************************/
 
-WERROR _spoolss_4a(pipes_struct *p,
+WERROR _spoolss_4a(struct pipes_struct *p,
                   struct spoolss_4a *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_4a *r)
 {
        p->rng_fault_state = true;
@@ -9438,7 +9742,7 @@ WERROR _spoolss_4a(pipes_struct *p,
  _spoolss_4b
 ****************************************************************/
 
  _spoolss_4b
 ****************************************************************/
 
-WERROR _spoolss_4b(pipes_struct *p,
+WERROR _spoolss_4b(struct pipes_struct *p,
                   struct spoolss_4b *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_4b *r)
 {
        p->rng_fault_state = true;
@@ -9449,7 +9753,7 @@ WERROR _spoolss_4b(pipes_struct *p,
  _spoolss_4c
 ****************************************************************/
 
  _spoolss_4c
 ****************************************************************/
 
-WERROR _spoolss_4c(pipes_struct *p,
+WERROR _spoolss_4c(struct pipes_struct *p,
                   struct spoolss_4c *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_4c *r)
 {
        p->rng_fault_state = true;
@@ -9460,7 +9764,7 @@ WERROR _spoolss_4c(pipes_struct *p,
  _spoolss_53
 ****************************************************************/
 
  _spoolss_53
 ****************************************************************/
 
-WERROR _spoolss_53(pipes_struct *p,
+WERROR _spoolss_53(struct pipes_struct *p,
                   struct spoolss_53 *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_53 *r)
 {
        p->rng_fault_state = true;
@@ -9471,7 +9775,7 @@ WERROR _spoolss_53(pipes_struct *p,
  _spoolss_55
 ****************************************************************/
 
  _spoolss_55
 ****************************************************************/
 
-WERROR _spoolss_55(pipes_struct *p,
+WERROR _spoolss_55(struct pipes_struct *p,
                   struct spoolss_55 *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_55 *r)
 {
        p->rng_fault_state = true;
@@ -9482,7 +9786,7 @@ WERROR _spoolss_55(pipes_struct *p,
  _spoolss_56
 ****************************************************************/
 
  _spoolss_56
 ****************************************************************/
 
-WERROR _spoolss_56(pipes_struct *p,
+WERROR _spoolss_56(struct pipes_struct *p,
                   struct spoolss_56 *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_56 *r)
 {
        p->rng_fault_state = true;
@@ -9493,7 +9797,7 @@ WERROR _spoolss_56(pipes_struct *p,
  _spoolss_57
 ****************************************************************/
 
  _spoolss_57
 ****************************************************************/
 
-WERROR _spoolss_57(pipes_struct *p,
+WERROR _spoolss_57(struct pipes_struct *p,
                   struct spoolss_57 *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_57 *r)
 {
        p->rng_fault_state = true;
@@ -9504,7 +9808,7 @@ WERROR _spoolss_57(pipes_struct *p,
  _spoolss_5a
 ****************************************************************/
 
  _spoolss_5a
 ****************************************************************/
 
-WERROR _spoolss_5a(pipes_struct *p,
+WERROR _spoolss_5a(struct pipes_struct *p,
                   struct spoolss_5a *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_5a *r)
 {
        p->rng_fault_state = true;
@@ -9515,7 +9819,7 @@ WERROR _spoolss_5a(pipes_struct *p,
  _spoolss_5b
 ****************************************************************/
 
  _spoolss_5b
 ****************************************************************/
 
-WERROR _spoolss_5b(pipes_struct *p,
+WERROR _spoolss_5b(struct pipes_struct *p,
                   struct spoolss_5b *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_5b *r)
 {
        p->rng_fault_state = true;
@@ -9526,7 +9830,7 @@ WERROR _spoolss_5b(pipes_struct *p,
  _spoolss_5c
 ****************************************************************/
 
  _spoolss_5c
 ****************************************************************/
 
-WERROR _spoolss_5c(pipes_struct *p,
+WERROR _spoolss_5c(struct pipes_struct *p,
                   struct spoolss_5c *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_5c *r)
 {
        p->rng_fault_state = true;
@@ -9537,7 +9841,7 @@ WERROR _spoolss_5c(pipes_struct *p,
  _spoolss_5d
 ****************************************************************/
 
  _spoolss_5d
 ****************************************************************/
 
-WERROR _spoolss_5d(pipes_struct *p,
+WERROR _spoolss_5d(struct pipes_struct *p,
                   struct spoolss_5d *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_5d *r)
 {
        p->rng_fault_state = true;
@@ -9548,7 +9852,7 @@ WERROR _spoolss_5d(pipes_struct *p,
  _spoolss_5e
 ****************************************************************/
 
  _spoolss_5e
 ****************************************************************/
 
-WERROR _spoolss_5e(pipes_struct *p,
+WERROR _spoolss_5e(struct pipes_struct *p,
                   struct spoolss_5e *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_5e *r)
 {
        p->rng_fault_state = true;
@@ -9559,7 +9863,7 @@ WERROR _spoolss_5e(pipes_struct *p,
  _spoolss_5f
 ****************************************************************/
 
  _spoolss_5f
 ****************************************************************/
 
-WERROR _spoolss_5f(pipes_struct *p,
+WERROR _spoolss_5f(struct pipes_struct *p,
                   struct spoolss_5f *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_5f *r)
 {
        p->rng_fault_state = true;
@@ -9570,7 +9874,7 @@ WERROR _spoolss_5f(pipes_struct *p,
  _spoolss_60
 ****************************************************************/
 
  _spoolss_60
 ****************************************************************/
 
-WERROR _spoolss_60(pipes_struct *p,
+WERROR _spoolss_60(struct pipes_struct *p,
                   struct spoolss_60 *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_60 *r)
 {
        p->rng_fault_state = true;
@@ -9581,7 +9885,7 @@ WERROR _spoolss_60(pipes_struct *p,
  _spoolss_61
 ****************************************************************/
 
  _spoolss_61
 ****************************************************************/
 
-WERROR _spoolss_61(pipes_struct *p,
+WERROR _spoolss_61(struct pipes_struct *p,
                   struct spoolss_61 *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_61 *r)
 {
        p->rng_fault_state = true;
@@ -9592,7 +9896,7 @@ WERROR _spoolss_61(pipes_struct *p,
  _spoolss_62
 ****************************************************************/
 
  _spoolss_62
 ****************************************************************/
 
-WERROR _spoolss_62(pipes_struct *p,
+WERROR _spoolss_62(struct pipes_struct *p,
                   struct spoolss_62 *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_62 *r)
 {
        p->rng_fault_state = true;
@@ -9603,7 +9907,7 @@ WERROR _spoolss_62(pipes_struct *p,
  _spoolss_63
 ****************************************************************/
 
  _spoolss_63
 ****************************************************************/
 
-WERROR _spoolss_63(pipes_struct *p,
+WERROR _spoolss_63(struct pipes_struct *p,
                   struct spoolss_63 *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_63 *r)
 {
        p->rng_fault_state = true;
@@ -9614,7 +9918,7 @@ WERROR _spoolss_63(pipes_struct *p,
  _spoolss_64
 ****************************************************************/
 
  _spoolss_64
 ****************************************************************/
 
-WERROR _spoolss_64(pipes_struct *p,
+WERROR _spoolss_64(struct pipes_struct *p,
                   struct spoolss_64 *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_64 *r)
 {
        p->rng_fault_state = true;
@@ -9625,7 +9929,7 @@ WERROR _spoolss_64(pipes_struct *p,
  _spoolss_65
 ****************************************************************/
 
  _spoolss_65
 ****************************************************************/
 
-WERROR _spoolss_65(pipes_struct *p,
+WERROR _spoolss_65(struct pipes_struct *p,
                   struct spoolss_65 *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_65 *r)
 {
        p->rng_fault_state = true;
@@ -9636,7 +9940,7 @@ WERROR _spoolss_65(pipes_struct *p,
  _spoolss_GetCorePrinterDrivers
 ****************************************************************/
 
  _spoolss_GetCorePrinterDrivers
 ****************************************************************/
 
-WERROR _spoolss_GetCorePrinterDrivers(pipes_struct *p,
+WERROR _spoolss_GetCorePrinterDrivers(struct pipes_struct *p,
                                      struct spoolss_GetCorePrinterDrivers *r)
 {
        p->rng_fault_state = true;
                                      struct spoolss_GetCorePrinterDrivers *r)
 {
        p->rng_fault_state = true;
@@ -9647,7 +9951,7 @@ WERROR _spoolss_GetCorePrinterDrivers(pipes_struct *p,
  _spoolss_67
 ****************************************************************/
 
  _spoolss_67
 ****************************************************************/
 
-WERROR _spoolss_67(pipes_struct *p,
+WERROR _spoolss_67(struct pipes_struct *p,
                   struct spoolss_67 *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_67 *r)
 {
        p->rng_fault_state = true;
@@ -9658,7 +9962,7 @@ WERROR _spoolss_67(pipes_struct *p,
  _spoolss_GetPrinterDriverPackagePath
 ****************************************************************/
 
  _spoolss_GetPrinterDriverPackagePath
 ****************************************************************/
 
-WERROR _spoolss_GetPrinterDriverPackagePath(pipes_struct *p,
+WERROR _spoolss_GetPrinterDriverPackagePath(struct pipes_struct *p,
                                            struct spoolss_GetPrinterDriverPackagePath *r)
 {
        p->rng_fault_state = true;
                                            struct spoolss_GetPrinterDriverPackagePath *r)
 {
        p->rng_fault_state = true;
@@ -9669,7 +9973,7 @@ WERROR _spoolss_GetPrinterDriverPackagePath(pipes_struct *p,
  _spoolss_69
 ****************************************************************/
 
  _spoolss_69
 ****************************************************************/
 
-WERROR _spoolss_69(pipes_struct *p,
+WERROR _spoolss_69(struct pipes_struct *p,
                   struct spoolss_69 *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_69 *r)
 {
        p->rng_fault_state = true;
@@ -9680,7 +9984,7 @@ WERROR _spoolss_69(pipes_struct *p,
  _spoolss_6a
 ****************************************************************/
 
  _spoolss_6a
 ****************************************************************/
 
-WERROR _spoolss_6a(pipes_struct *p,
+WERROR _spoolss_6a(struct pipes_struct *p,
                   struct spoolss_6a *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_6a *r)
 {
        p->rng_fault_state = true;
@@ -9691,7 +9995,7 @@ WERROR _spoolss_6a(pipes_struct *p,
  _spoolss_6b
 ****************************************************************/
 
  _spoolss_6b
 ****************************************************************/
 
-WERROR _spoolss_6b(pipes_struct *p,
+WERROR _spoolss_6b(struct pipes_struct *p,
                   struct spoolss_6b *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_6b *r)
 {
        p->rng_fault_state = true;
@@ -9702,7 +10006,7 @@ WERROR _spoolss_6b(pipes_struct *p,
  _spoolss_6c
 ****************************************************************/
 
  _spoolss_6c
 ****************************************************************/
 
-WERROR _spoolss_6c(pipes_struct *p,
+WERROR _spoolss_6c(struct pipes_struct *p,
                   struct spoolss_6c *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_6c *r)
 {
        p->rng_fault_state = true;
@@ -9713,7 +10017,7 @@ WERROR _spoolss_6c(pipes_struct *p,
  _spoolss_6d
 ****************************************************************/
 
  _spoolss_6d
 ****************************************************************/
 
-WERROR _spoolss_6d(pipes_struct *p,
+WERROR _spoolss_6d(struct pipes_struct *p,
                   struct spoolss_6d *r)
 {
        p->rng_fault_state = true;
                   struct spoolss_6d *r)
 {
        p->rng_fault_state = true;
Samba Shared Repository