s3: re-run make samba3-idl.

[kai/samba-autobuild/.git] / librpc / gen_ndr / srv_spoolss.c

diff --git a/librpc/gen_ndr/srv_spoolss.c b/librpc/gen_ndr/srv_spoolss.c
index abf49766a4659711a2c604d9781351c547928848..0ac29d408a4c5cbbda04cc9f0271d4902405da75 100644 (file)
--- a/librpc/gen_ndr/srv_spoolss.c
+++ b/librpc/gen_ndr/srv_spoolss.c
@@ -45,20 +45,20 @@ static bool api_spoolss_EnumPrinters(pipes_struct *p)
        }
 
        ZERO_STRUCT(r->out);
-       r->out.info = talloc_zero_array(r, union spoolss_PrinterInfo, r->out.count);
-       if (r->out.info == NULL) {
+       r->out.count = talloc_zero(r, uint32_t);
+       if (r->out.count == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.needed = talloc_zero(r, uint32_t);
-       if (r->out.needed == NULL) {
+       r->out.info = talloc_zero(r, union spoolss_PrinterInfo *);
+       if (r->out.info == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.count = talloc_zero(r, uint32_t);
-       if (r->out.count == NULL) {
+       r->out.needed = talloc_zero(r, uint32_t);
+       if (r->out.needed == NULL) {
                talloc_free(r);
                return false;
        }
@@ -376,20 +376,20 @@ static bool api_spoolss_EnumJobs(pipes_struct *p)
        }
 
        ZERO_STRUCT(r->out);
-       r->out.info = talloc_zero_array(r, union spoolss_JobInfo, r->out.count);
-       if (r->out.info == NULL) {
+       r->out.count = talloc_zero(r, uint32_t);
+       if (r->out.count == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.needed = talloc_zero(r, uint32_t);
-       if (r->out.needed == NULL) {
+       r->out.info = talloc_zero(r, union spoolss_JobInfo *);
+       if (r->out.info == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.count = talloc_zero(r, uint32_t);
-       if (r->out.count == NULL) {
+       r->out.needed = talloc_zero(r, uint32_t);
+       if (r->out.needed == NULL) {
                talloc_free(r);
                return false;
        }
@@ -467,6 +467,13 @@ static bool api_spoolss_AddPrinter(pipes_struct *p)
                NDR_PRINT_IN_DEBUG(spoolss_AddPrinter, r);
        }
 
+       ZERO_STRUCT(r->out);
+       r->out.handle = talloc_zero(r, struct policy_handle);
+       if (r->out.handle == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
        r->out.result = _spoolss_AddPrinter(p, r);
 
        if (p->rng_fault_state) {
@@ -846,20 +853,20 @@ static bool api_spoolss_EnumPrinterDrivers(pipes_struct *p)
        }
 
        ZERO_STRUCT(r->out);
-       r->out.info = talloc_zero_array(r, union spoolss_DriverInfo, r->out.count);
-       if (r->out.info == NULL) {
+       r->out.count = talloc_zero(r, uint32_t);
+       if (r->out.count == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.needed = talloc_zero(r, uint32_t);
-       if (r->out.needed == NULL) {
+       r->out.info = talloc_zero(r, union spoolss_DriverInfo *);
+       if (r->out.info == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.count = talloc_zero(r, uint32_t);
-       if (r->out.count == NULL) {
+       r->out.needed = talloc_zero(r, uint32_t);
+       if (r->out.needed == NULL) {
                talloc_free(r);
                return false;
        }
@@ -937,6 +944,19 @@ static bool api_spoolss_GetPrinterDriver(pipes_struct *p)
                NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriver, r);
        }
 
+       ZERO_STRUCT(r->out);
+       r->out.info = talloc_zero(r, union spoolss_DriverInfo);
+       if (r->out.info == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       r->out.needed = talloc_zero(r, uint32_t);
+       if (r->out.needed == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
        r->out.result = _spoolss_GetPrinterDriver(p, r);
 
        if (p->rng_fault_state) {
@@ -1243,20 +1263,20 @@ static bool api_spoolss_EnumPrintProcessors(pipes_struct *p)
        }
 
        ZERO_STRUCT(r->out);
-       r->out.info = talloc_zero_array(r, union spoolss_PrintProcessorInfo, r->out.count);
-       if (r->out.info == NULL) {
+       r->out.count = talloc_zero(r, uint32_t);
+       if (r->out.count == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.needed = talloc_zero(r, uint32_t);
-       if (r->out.needed == NULL) {
+       r->out.info = talloc_zero(r, union spoolss_PrintProcessorInfo *);
+       if (r->out.info == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.count = talloc_zero(r, uint32_t);
-       if (r->out.count == NULL) {
+       r->out.needed = talloc_zero(r, uint32_t);
+       if (r->out.needed == NULL) {
                talloc_free(r);
                return false;
        }
@@ -1334,6 +1354,19 @@ static bool api_spoolss_GetPrintProcessorDirectory(pipes_struct *p)
                NDR_PRINT_IN_DEBUG(spoolss_GetPrintProcessorDirectory, r);
        }
 
+       ZERO_STRUCT(r->out);
+       r->out.info = talloc_zero(r, union spoolss_PrintProcessorDirectoryInfo);
+       if (r->out.info == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       r->out.needed = talloc_zero(r, uint32_t);
+       if (r->out.needed == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
        r->out.result = _spoolss_GetPrintProcessorDirectory(p, r);
 
        if (p->rng_fault_state) {
@@ -1787,7 +1820,7 @@ static bool api_spoolss_ReadPrinter(pipes_struct *p)
        }
 
        ZERO_STRUCT(r->out);
-       r->out.data = talloc_zero(r, DATA_BLOB);
+       r->out.data = talloc_zero_array(r, uint8_t, r->in.data_size);
        if (r->out.data == NULL) {
                talloc_free(r);
                return false;
@@ -1945,6 +1978,14 @@ static bool api_spoolss_AddJob(pipes_struct *p)
                NDR_PRINT_IN_DEBUG(spoolss_AddJob, r);
        }
 
+       ZERO_STRUCT(r->out);
+       r->out.buffer = r->in.buffer;
+       r->out.needed = talloc_zero(r, uint32_t);
+       if (r->out.needed == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
        r->out.result = _spoolss_AddJob(p, r);
 
        if (p->rng_fault_state) {
@@ -2092,13 +2133,13 @@ static bool api_spoolss_GetPrinterData(pipes_struct *p)
        }
 
        ZERO_STRUCT(r->out);
-       r->out.type = talloc_zero(r, enum spoolss_PrinterDataType);
+       r->out.type = talloc_zero(r, enum winreg_Type);
        if (r->out.type == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.data = talloc_zero(r, union spoolss_PrinterData);
+       r->out.data = talloc_zero_array(r, uint8_t, r->in.offered);
        if (r->out.data == NULL) {
                talloc_free(r);
                return false;
@@ -2710,20 +2751,20 @@ static bool api_spoolss_EnumForms(pipes_struct *p)
        }
 
        ZERO_STRUCT(r->out);
-       r->out.info = talloc_zero_array(r, union spoolss_FormInfo, r->out.count);
-       if (r->out.info == NULL) {
+       r->out.count = talloc_zero(r, uint32_t);
+       if (r->out.count == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.needed = talloc_zero(r, uint32_t);
-       if (r->out.needed == NULL) {
+       r->out.info = talloc_zero(r, union spoolss_FormInfo *);
+       if (r->out.info == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.count = talloc_zero(r, uint32_t);
-       if (r->out.count == NULL) {
+       r->out.needed = talloc_zero(r, uint32_t);
+       if (r->out.needed == NULL) {
                talloc_free(r);
                return false;
        }
@@ -2802,20 +2843,20 @@ static bool api_spoolss_EnumPorts(pipes_struct *p)
        }
 
        ZERO_STRUCT(r->out);
-       r->out.info = talloc_zero_array(r, union spoolss_PortInfo, r->out.count);
-       if (r->out.info == NULL) {
+       r->out.count = talloc_zero(r, uint32_t);
+       if (r->out.count == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.needed = talloc_zero(r, uint32_t);
-       if (r->out.needed == NULL) {
+       r->out.info = talloc_zero(r, union spoolss_PortInfo *);
+       if (r->out.info == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.count = talloc_zero(r, uint32_t);
-       if (r->out.count == NULL) {
+       r->out.needed = talloc_zero(r, uint32_t);
+       if (r->out.needed == NULL) {
                talloc_free(r);
                return false;
        }
@@ -2894,20 +2935,20 @@ static bool api_spoolss_EnumMonitors(pipes_struct *p)
        }
 
        ZERO_STRUCT(r->out);
-       r->out.info = talloc_zero_array(r, union spoolss_MonitorInfo, r->out.count);
-       if (r->out.info == NULL) {
+       r->out.count = talloc_zero(r, uint32_t);
+       if (r->out.count == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.needed = talloc_zero(r, uint32_t);
-       if (r->out.needed == NULL) {
+       r->out.info = talloc_zero(r, union spoolss_MonitorInfo *);
+       if (r->out.info == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.count = talloc_zero(r, uint32_t);
-       if (r->out.count == NULL) {
+       r->out.needed = talloc_zero(r, uint32_t);
+       if (r->out.needed == NULL) {
                talloc_free(r);
                return false;
        }
@@ -3204,6 +3245,13 @@ static bool api_spoolss_CreatePrinterIC(pipes_struct *p)
                NDR_PRINT_IN_DEBUG(spoolss_CreatePrinterIC, r);
        }
 
+       ZERO_STRUCT(r->out);
+       r->out.gdi_handle = talloc_zero(r, struct policy_handle);
+       if (r->out.gdi_handle == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
        r->out.result = _spoolss_CreatePrinterIC(p, r);
 
        if (p->rng_fault_state) {
@@ -3350,6 +3398,8 @@ static bool api_spoolss_DeletePrinterIC(pipes_struct *p)
                NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterIC, r);
        }
 
+       ZERO_STRUCT(r->out);
+       r->out.gdi_handle = r->in.gdi_handle;
        r->out.result = _spoolss_DeletePrinterIC(p, r);
 
        if (p->rng_fault_state) {
@@ -4007,6 +4057,25 @@ static bool api_spoolss_EnumPrintProcDataTypes(pipes_struct *p)
                NDR_PRINT_IN_DEBUG(spoolss_EnumPrintProcDataTypes, r);
        }
 
+       ZERO_STRUCT(r->out);
+       r->out.count = talloc_zero(r, uint32_t);
+       if (r->out.count == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       r->out.info = talloc_zero(r, union spoolss_PrintProcDataTypesInfo *);
+       if (r->out.info == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       r->out.needed = talloc_zero(r, uint32_t);
+       if (r->out.needed == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
        r->out.result = _spoolss_EnumPrintProcDataTypes(p, r);
 
        if (p->rng_fault_state) {
@@ -4154,7 +4223,7 @@ static bool api_spoolss_GetPrinterDriver2(pipes_struct *p)
        }
 
        ZERO_STRUCT(r->out);
-       r->out.info = talloc_zero(r, DATA_BLOB);
+       r->out.info = talloc_zero(r, union spoolss_DriverInfo);
        if (r->out.info == NULL) {
                talloc_free(r);
                return false;
@@ -5098,18 +5167,18 @@ static bool api_spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct *p)
        return true;
 }
 
-static bool api_spoolss_RouterRefreshPrinterChangeNotification(pipes_struct *p)
+static bool api_spoolss_RouterReplyPrinterEx(pipes_struct *p)
 {
        const struct ndr_interface_call *call;
        struct ndr_pull *pull;
        struct ndr_push *push;
        enum ndr_err_code ndr_err;
        DATA_BLOB blob;
-       struct spoolss_RouterRefreshPrinterChangeNotification *r;
+       struct spoolss_RouterReplyPrinterEx *r;
 
-       call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFICATION];
+       call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ROUTERREPLYPRINTEREX];
 
-       r = talloc(talloc_tos(), struct spoolss_RouterRefreshPrinterChangeNotification);
+       r = talloc(talloc_tos(), struct spoolss_RouterReplyPrinterEx);
        if (r == NULL) {
                return false;
        }
@@ -5133,10 +5202,17 @@ static bool api_spoolss_RouterRefreshPrinterChangeNotification(pipes_struct *p)
        }
 
        if (DEBUGLEVEL >= 10) {
-               NDR_PRINT_IN_DEBUG(spoolss_RouterRefreshPrinterChangeNotification, r);
+               NDR_PRINT_IN_DEBUG(spoolss_RouterReplyPrinterEx, r);
+       }
+
+       ZERO_STRUCT(r->out);
+       r->out.reply_result = talloc_zero(r, uint32_t);
+       if (r->out.reply_result == NULL) {
+               talloc_free(r);
+               return false;
        }
 
-       r->out.result = _spoolss_RouterRefreshPrinterChangeNotification(p, r);
+       r->out.result = _spoolss_RouterReplyPrinterEx(p, r);
 
        if (p->rng_fault_state) {
                talloc_free(r);
@@ -5145,7 +5221,7 @@ static bool api_spoolss_RouterRefreshPrinterChangeNotification(pipes_struct *p)
        }
 
        if (DEBUGLEVEL >= 10) {
-               NDR_PRINT_OUT_DEBUG(spoolss_RouterRefreshPrinterChangeNotification, r);
+               NDR_PRINT_OUT_DEBUG(spoolss_RouterReplyPrinterEx, r);
        }
 
        push = ndr_push_init_ctx(r, NULL);
@@ -5171,18 +5247,18 @@ static bool api_spoolss_RouterRefreshPrinterChangeNotification(pipes_struct *p)
        return true;
 }
 
-static bool api_spoolss_RemoteFindNextPrinterChangeNotifyEx(pipes_struct *p)
+static bool api_spoolss_RouterRefreshPrinterChangeNotify(pipes_struct *p)
 {
        const struct ndr_interface_call *call;
        struct ndr_pull *pull;
        struct ndr_push *push;
        enum ndr_err_code ndr_err;
        DATA_BLOB blob;
-       struct spoolss_RemoteFindNextPrinterChangeNotifyEx *r;
+       struct spoolss_RouterRefreshPrinterChangeNotify *r;
 
-       call = &ndr_table_spoolss.calls[NDR_SPOOLSS_REMOTEFINDNEXTPRINTERCHANGENOTIFYEX];
+       call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY];
 
-       r = talloc(talloc_tos(), struct spoolss_RemoteFindNextPrinterChangeNotifyEx);
+       r = talloc(talloc_tos(), struct spoolss_RouterRefreshPrinterChangeNotify);
        if (r == NULL) {
                return false;
        }
@@ -5206,7 +5282,7 @@ static bool api_spoolss_RemoteFindNextPrinterChangeNotifyEx(pipes_struct *p)
        }
 
        if (DEBUGLEVEL >= 10) {
-               NDR_PRINT_IN_DEBUG(spoolss_RemoteFindNextPrinterChangeNotifyEx, r);
+               NDR_PRINT_IN_DEBUG(spoolss_RouterRefreshPrinterChangeNotify, r);
        }
 
        ZERO_STRUCT(r->out);
@@ -5216,7 +5292,7 @@ static bool api_spoolss_RemoteFindNextPrinterChangeNotifyEx(pipes_struct *p)
                return false;
        }
 
-       r->out.result = _spoolss_RemoteFindNextPrinterChangeNotifyEx(p, r);
+       r->out.result = _spoolss_RouterRefreshPrinterChangeNotify(p, r);
 
        if (p->rng_fault_state) {
                talloc_free(r);
@@ -5225,7 +5301,7 @@ static bool api_spoolss_RemoteFindNextPrinterChangeNotifyEx(pipes_struct *p)
        }
 
        if (DEBUGLEVEL >= 10) {
-               NDR_PRINT_OUT_DEBUG(spoolss_RemoteFindNextPrinterChangeNotifyEx, r);
+               NDR_PRINT_OUT_DEBUG(spoolss_RouterRefreshPrinterChangeNotify, r);
        }
 
        push = ndr_push_init_ctx(r, NULL);
@@ -5442,6 +5518,13 @@ static bool api_spoolss_AddPrinterEx(pipes_struct *p)
                NDR_PRINT_IN_DEBUG(spoolss_AddPrinterEx, r);
        }
 
+       ZERO_STRUCT(r->out);
+       r->out.handle = talloc_zero(r, struct policy_handle);
+       if (r->out.handle == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
        r->out.result = _spoolss_AddPrinterEx(p, r);
 
        if (p->rng_fault_state) {
@@ -5601,14 +5684,14 @@ static bool api_spoolss_EnumPrinterData(pipes_struct *p)
                return false;
        }
 
-       r->out.printerdata_type = talloc_zero(r, uint32_t);
-       if (r->out.printerdata_type == NULL) {
+       r->out.type = talloc_zero(r, enum winreg_Type);
+       if (r->out.type == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.buffer = talloc_zero(r, DATA_BLOB);
-       if (r->out.buffer == NULL) {
+       r->out.data = talloc_zero_array(r, uint8_t, r->in.data_offered);
+       if (r->out.data == NULL) {
                talloc_free(r);
                return false;
        }
@@ -6058,14 +6141,14 @@ static bool api_spoolss_GetPrinterDataEx(pipes_struct *p)
        }
 
        ZERO_STRUCT(r->out);
-       r->out.type = talloc_zero(r, uint32_t);
+       r->out.type = talloc_zero(r, enum winreg_Type);
        if (r->out.type == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.buffer = talloc_zero(r, DATA_BLOB);
-       if (r->out.buffer == NULL) {
+       r->out.data = talloc_zero_array(r, uint8_t, r->in.offered);
+       if (r->out.data == NULL) {
                talloc_free(r);
                return false;
        }
@@ -6150,20 +6233,20 @@ static bool api_spoolss_EnumPrinterDataEx(pipes_struct *p)
        }
 
        ZERO_STRUCT(r->out);
-       r->out.buffer = talloc_zero(r, DATA_BLOB);
-       if (r->out.buffer == NULL) {
+       r->out.count = talloc_zero(r, uint32_t);
+       if (r->out.count == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.needed = talloc_zero(r, uint32_t);
-       if (r->out.needed == NULL) {
+       r->out.info = talloc_zero(r, struct spoolss_PrinterEnumValues *);
+       if (r->out.info == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.count = talloc_zero(r, uint32_t);
-       if (r->out.count == NULL) {
+       r->out.needed = talloc_zero(r, uint32_t);
+       if (r->out.needed == NULL) {
                talloc_free(r);
                return false;
        }
@@ -6242,19 +6325,24 @@ static bool api_spoolss_EnumPrinterKey(pipes_struct *p)
        }
 
        ZERO_STRUCT(r->out);
-       r->out.needed = r->in.needed;
-       r->out.key_buffer_size = talloc_zero(r, uint32_t);
-       if (r->out.key_buffer_size == NULL) {
+       r->out._ndr_size = talloc_zero(r, uint32_t);
+       if (r->out._ndr_size == NULL) {
                talloc_free(r);
                return false;
        }
 
-       r->out.key_buffer = talloc_zero_array(r, uint16_t, r->out.key_buffer_size);
+       r->out.key_buffer = talloc_zero(r, union spoolss_KeyNames);
        if (r->out.key_buffer == NULL) {
                talloc_free(r);
                return false;
        }
 
+       r->out.needed = talloc_zero(r, uint32_t);
+       if (r->out.needed == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
        r->out.result = _spoolss_EnumPrinterKey(p, r);
 
        if (p->rng_fault_state) {
@@ -6840,7 +6928,8 @@ static bool api_spoolss_XcvData(pipes_struct *p)
        }
 
        ZERO_STRUCT(r->out);
-       r->out.out_data = talloc_zero(r, DATA_BLOB);
+       r->out.status_code = r->in.status_code;
+       r->out.out_data = talloc_zero_array(r, uint8_t, r->in.out_data_size);
        if (r->out.out_data == NULL) {
                talloc_free(r);
                return false;
@@ -6852,12 +6941,6 @@ static bool api_spoolss_XcvData(pipes_struct *p)
                return false;
        }
 
-       r->out.unknown2 = talloc_zero(r, uint32_t);
-       if (r->out.unknown2 == NULL) {
-               talloc_free(r);
-               return false;
-       }
-
        r->out.result = _spoolss_XcvData(p, r);
 
        if (p->rng_fault_state) {
@@ -7404,33 +7487,1070 @@ static bool api_spoolss_5f(pipes_struct *p)
        return true;
 }
 
+static bool api_spoolss_60(pipes_struct *p)
+{
+       const struct ndr_interface_call *call;
+       struct ndr_pull *pull;
+       struct ndr_push *push;
+       enum ndr_err_code ndr_err;
+       DATA_BLOB blob;
+       struct spoolss_60 *r;
+
+       call = &ndr_table_spoolss.calls[NDR_SPOOLSS_60];
 
-/* Tables */
-static struct api_struct api_spoolss_cmds[] = 
+       r = talloc(talloc_tos(), struct spoolss_60);
+       if (r == NULL) {
+               return false;
+       }
+
+       if (!prs_data_blob(&p->in_data.data, &blob, r)) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull = ndr_pull_init_blob(&blob, r, NULL);
+       if (pull == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull->flags |= LIBNDR_FLAG_REF_ALLOC;
+       ndr_err = call->ndr_pull(pull, NDR_IN, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(spoolss_60, r);
+       }
+
+       r->out.result = _spoolss_60(p, r);
+
+       if (p->rng_fault_state) {
+               talloc_free(r);
+               /* Return true here, srv_pipe_hnd.c will take care */
+               return true;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(spoolss_60, r);
+       }
+
+       push = ndr_push_init_ctx(r, NULL);
+       if (push == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       ndr_err = call->ndr_push(push, NDR_OUT, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       blob = ndr_push_blob(push);
+       if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
+               talloc_free(r);
+               return false;
+       }
+
+       talloc_free(r);
+
+       return true;
+}
+
+static bool api_spoolss_61(pipes_struct *p)
 {
-       {"SPOOLSS_ENUMPRINTERS", NDR_SPOOLSS_ENUMPRINTERS, api_spoolss_EnumPrinters},
-       {"SPOOLSS_OPENPRINTER", NDR_SPOOLSS_OPENPRINTER, api_spoolss_OpenPrinter},
-       {"SPOOLSS_SETJOB", NDR_SPOOLSS_SETJOB, api_spoolss_SetJob},
-       {"SPOOLSS_GETJOB", NDR_SPOOLSS_GETJOB, api_spoolss_GetJob},
-       {"SPOOLSS_ENUMJOBS", NDR_SPOOLSS_ENUMJOBS, api_spoolss_EnumJobs},
-       {"SPOOLSS_ADDPRINTER", NDR_SPOOLSS_ADDPRINTER, api_spoolss_AddPrinter},
-       {"SPOOLSS_DELETEPRINTER", NDR_SPOOLSS_DELETEPRINTER, api_spoolss_DeletePrinter},
-       {"SPOOLSS_SETPRINTER", NDR_SPOOLSS_SETPRINTER, api_spoolss_SetPrinter},
-       {"SPOOLSS_GETPRINTER", NDR_SPOOLSS_GETPRINTER, api_spoolss_GetPrinter},
-       {"SPOOLSS_ADDPRINTERDRIVER", NDR_SPOOLSS_ADDPRINTERDRIVER, api_spoolss_AddPrinterDriver},
-       {"SPOOLSS_ENUMPRINTERDRIVERS", NDR_SPOOLSS_ENUMPRINTERDRIVERS, api_spoolss_EnumPrinterDrivers},
-       {"SPOOLSS_GETPRINTERDRIVER", NDR_SPOOLSS_GETPRINTERDRIVER, api_spoolss_GetPrinterDriver},
-       {"SPOOLSS_GETPRINTERDRIVERDIRECTORY", NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY, api_spoolss_GetPrinterDriverDirectory},
-       {"SPOOLSS_DELETEPRINTERDRIVER", NDR_SPOOLSS_DELETEPRINTERDRIVER, api_spoolss_DeletePrinterDriver},
-       {"SPOOLSS_ADDPRINTPROCESSOR", NDR_SPOOLSS_ADDPRINTPROCESSOR, api_spoolss_AddPrintProcessor},
-       {"SPOOLSS_ENUMPRINTPROCESSORS", NDR_SPOOLSS_ENUMPRINTPROCESSORS, api_spoolss_EnumPrintProcessors},
-       {"SPOOLSS_GETPRINTPROCESSORDIRECTORY", NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY, api_spoolss_GetPrintProcessorDirectory},
-       {"SPOOLSS_STARTDOCPRINTER", NDR_SPOOLSS_STARTDOCPRINTER, api_spoolss_StartDocPrinter},
-       {"SPOOLSS_STARTPAGEPRINTER", NDR_SPOOLSS_STARTPAGEPRINTER, api_spoolss_StartPagePrinter},
-       {"SPOOLSS_WRITEPRINTER", NDR_SPOOLSS_WRITEPRINTER, api_spoolss_WritePrinter},
-       {"SPOOLSS_ENDPAGEPRINTER", NDR_SPOOLSS_ENDPAGEPRINTER, api_spoolss_EndPagePrinter},
-       {"SPOOLSS_ABORTPRINTER", NDR_SPOOLSS_ABORTPRINTER, api_spoolss_AbortPrinter},
-       {"SPOOLSS_READPRINTER", NDR_SPOOLSS_READPRINTER, api_spoolss_ReadPrinter},
+       const struct ndr_interface_call *call;
+       struct ndr_pull *pull;
+       struct ndr_push *push;
+       enum ndr_err_code ndr_err;
+       DATA_BLOB blob;
+       struct spoolss_61 *r;
+
+       call = &ndr_table_spoolss.calls[NDR_SPOOLSS_61];
+
+       r = talloc(talloc_tos(), struct spoolss_61);
+       if (r == NULL) {
+               return false;
+       }
+
+       if (!prs_data_blob(&p->in_data.data, &blob, r)) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull = ndr_pull_init_blob(&blob, r, NULL);
+       if (pull == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull->flags |= LIBNDR_FLAG_REF_ALLOC;
+       ndr_err = call->ndr_pull(pull, NDR_IN, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(spoolss_61, r);
+       }
+
+       r->out.result = _spoolss_61(p, r);
+
+       if (p->rng_fault_state) {
+               talloc_free(r);
+               /* Return true here, srv_pipe_hnd.c will take care */
+               return true;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(spoolss_61, r);
+       }
+
+       push = ndr_push_init_ctx(r, NULL);
+       if (push == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       ndr_err = call->ndr_push(push, NDR_OUT, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       blob = ndr_push_blob(push);
+       if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
+               talloc_free(r);
+               return false;
+       }
+
+       talloc_free(r);
+
+       return true;
+}
+
+static bool api_spoolss_62(pipes_struct *p)
+{
+       const struct ndr_interface_call *call;
+       struct ndr_pull *pull;
+       struct ndr_push *push;
+       enum ndr_err_code ndr_err;
+       DATA_BLOB blob;
+       struct spoolss_62 *r;
+
+       call = &ndr_table_spoolss.calls[NDR_SPOOLSS_62];
+
+       r = talloc(talloc_tos(), struct spoolss_62);
+       if (r == NULL) {
+               return false;
+       }
+
+       if (!prs_data_blob(&p->in_data.data, &blob, r)) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull = ndr_pull_init_blob(&blob, r, NULL);
+       if (pull == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull->flags |= LIBNDR_FLAG_REF_ALLOC;
+       ndr_err = call->ndr_pull(pull, NDR_IN, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(spoolss_62, r);
+       }
+
+       r->out.result = _spoolss_62(p, r);
+
+       if (p->rng_fault_state) {
+               talloc_free(r);
+               /* Return true here, srv_pipe_hnd.c will take care */
+               return true;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(spoolss_62, r);
+       }
+
+       push = ndr_push_init_ctx(r, NULL);
+       if (push == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       ndr_err = call->ndr_push(push, NDR_OUT, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       blob = ndr_push_blob(push);
+       if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
+               talloc_free(r);
+               return false;
+       }
+
+       talloc_free(r);
+
+       return true;
+}
+
+static bool api_spoolss_63(pipes_struct *p)
+{
+       const struct ndr_interface_call *call;
+       struct ndr_pull *pull;
+       struct ndr_push *push;
+       enum ndr_err_code ndr_err;
+       DATA_BLOB blob;
+       struct spoolss_63 *r;
+
+       call = &ndr_table_spoolss.calls[NDR_SPOOLSS_63];
+
+       r = talloc(talloc_tos(), struct spoolss_63);
+       if (r == NULL) {
+               return false;
+       }
+
+       if (!prs_data_blob(&p->in_data.data, &blob, r)) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull = ndr_pull_init_blob(&blob, r, NULL);
+       if (pull == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull->flags |= LIBNDR_FLAG_REF_ALLOC;
+       ndr_err = call->ndr_pull(pull, NDR_IN, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(spoolss_63, r);
+       }
+
+       r->out.result = _spoolss_63(p, r);
+
+       if (p->rng_fault_state) {
+               talloc_free(r);
+               /* Return true here, srv_pipe_hnd.c will take care */
+               return true;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(spoolss_63, r);
+       }
+
+       push = ndr_push_init_ctx(r, NULL);
+       if (push == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       ndr_err = call->ndr_push(push, NDR_OUT, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       blob = ndr_push_blob(push);
+       if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
+               talloc_free(r);
+               return false;
+       }
+
+       talloc_free(r);
+
+       return true;
+}
+
+static bool api_spoolss_64(pipes_struct *p)
+{
+       const struct ndr_interface_call *call;
+       struct ndr_pull *pull;
+       struct ndr_push *push;
+       enum ndr_err_code ndr_err;
+       DATA_BLOB blob;
+       struct spoolss_64 *r;
+
+       call = &ndr_table_spoolss.calls[NDR_SPOOLSS_64];
+
+       r = talloc(talloc_tos(), struct spoolss_64);
+       if (r == NULL) {
+               return false;
+       }
+
+       if (!prs_data_blob(&p->in_data.data, &blob, r)) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull = ndr_pull_init_blob(&blob, r, NULL);
+       if (pull == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull->flags |= LIBNDR_FLAG_REF_ALLOC;
+       ndr_err = call->ndr_pull(pull, NDR_IN, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(spoolss_64, r);
+       }
+
+       r->out.result = _spoolss_64(p, r);
+
+       if (p->rng_fault_state) {
+               talloc_free(r);
+               /* Return true here, srv_pipe_hnd.c will take care */
+               return true;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(spoolss_64, r);
+       }
+
+       push = ndr_push_init_ctx(r, NULL);
+       if (push == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       ndr_err = call->ndr_push(push, NDR_OUT, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       blob = ndr_push_blob(push);
+       if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
+               talloc_free(r);
+               return false;
+       }
+
+       talloc_free(r);
+
+       return true;
+}
+
+static bool api_spoolss_65(pipes_struct *p)
+{
+       const struct ndr_interface_call *call;
+       struct ndr_pull *pull;
+       struct ndr_push *push;
+       enum ndr_err_code ndr_err;
+       DATA_BLOB blob;
+       struct spoolss_65 *r;
+
+       call = &ndr_table_spoolss.calls[NDR_SPOOLSS_65];
+
+       r = talloc(talloc_tos(), struct spoolss_65);
+       if (r == NULL) {
+               return false;
+       }
+
+       if (!prs_data_blob(&p->in_data.data, &blob, r)) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull = ndr_pull_init_blob(&blob, r, NULL);
+       if (pull == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull->flags |= LIBNDR_FLAG_REF_ALLOC;
+       ndr_err = call->ndr_pull(pull, NDR_IN, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(spoolss_65, r);
+       }
+
+       r->out.result = _spoolss_65(p, r);
+
+       if (p->rng_fault_state) {
+               talloc_free(r);
+               /* Return true here, srv_pipe_hnd.c will take care */
+               return true;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(spoolss_65, r);
+       }
+
+       push = ndr_push_init_ctx(r, NULL);
+       if (push == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       ndr_err = call->ndr_push(push, NDR_OUT, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       blob = ndr_push_blob(push);
+       if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
+               talloc_free(r);
+               return false;
+       }
+
+       talloc_free(r);
+
+       return true;
+}
+
+static bool api_spoolss_GetCorePrinterDrivers(pipes_struct *p)
+{
+       const struct ndr_interface_call *call;
+       struct ndr_pull *pull;
+       struct ndr_push *push;
+       enum ndr_err_code ndr_err;
+       DATA_BLOB blob;
+       struct spoolss_GetCorePrinterDrivers *r;
+
+       call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETCOREPRINTERDRIVERS];
+
+       r = talloc(talloc_tos(), struct spoolss_GetCorePrinterDrivers);
+       if (r == NULL) {
+               return false;
+       }
+
+       if (!prs_data_blob(&p->in_data.data, &blob, r)) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull = ndr_pull_init_blob(&blob, r, NULL);
+       if (pull == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull->flags |= LIBNDR_FLAG_REF_ALLOC;
+       ndr_err = call->ndr_pull(pull, NDR_IN, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(spoolss_GetCorePrinterDrivers, r);
+       }
+
+       ZERO_STRUCT(r->out);
+       r->out.core_printer_drivers = talloc_zero_array(r, struct spoolss_CorePrinterDriver, r->in.core_printer_driver_count);
+       if (r->out.core_printer_drivers == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       r->out.result = _spoolss_GetCorePrinterDrivers(p, r);
+
+       if (p->rng_fault_state) {
+               talloc_free(r);
+               /* Return true here, srv_pipe_hnd.c will take care */
+               return true;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(spoolss_GetCorePrinterDrivers, r);
+       }
+
+       push = ndr_push_init_ctx(r, NULL);
+       if (push == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       ndr_err = call->ndr_push(push, NDR_OUT, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       blob = ndr_push_blob(push);
+       if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
+               talloc_free(r);
+               return false;
+       }
+
+       talloc_free(r);
+
+       return true;
+}
+
+static bool api_spoolss_67(pipes_struct *p)
+{
+       const struct ndr_interface_call *call;
+       struct ndr_pull *pull;
+       struct ndr_push *push;
+       enum ndr_err_code ndr_err;
+       DATA_BLOB blob;
+       struct spoolss_67 *r;
+
+       call = &ndr_table_spoolss.calls[NDR_SPOOLSS_67];
+
+       r = talloc(talloc_tos(), struct spoolss_67);
+       if (r == NULL) {
+               return false;
+       }
+
+       if (!prs_data_blob(&p->in_data.data, &blob, r)) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull = ndr_pull_init_blob(&blob, r, NULL);
+       if (pull == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull->flags |= LIBNDR_FLAG_REF_ALLOC;
+       ndr_err = call->ndr_pull(pull, NDR_IN, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(spoolss_67, r);
+       }
+
+       r->out.result = _spoolss_67(p, r);
+
+       if (p->rng_fault_state) {
+               talloc_free(r);
+               /* Return true here, srv_pipe_hnd.c will take care */
+               return true;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(spoolss_67, r);
+       }
+
+       push = ndr_push_init_ctx(r, NULL);
+       if (push == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       ndr_err = call->ndr_push(push, NDR_OUT, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       blob = ndr_push_blob(push);
+       if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
+               talloc_free(r);
+               return false;
+       }
+
+       talloc_free(r);
+
+       return true;
+}
+
+static bool api_spoolss_GetPrinterDriverPackagePath(pipes_struct *p)
+{
+       const struct ndr_interface_call *call;
+       struct ndr_pull *pull;
+       struct ndr_push *push;
+       enum ndr_err_code ndr_err;
+       DATA_BLOB blob;
+       struct spoolss_GetPrinterDriverPackagePath *r;
+
+       call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH];
+
+       r = talloc(talloc_tos(), struct spoolss_GetPrinterDriverPackagePath);
+       if (r == NULL) {
+               return false;
+       }
+
+       if (!prs_data_blob(&p->in_data.data, &blob, r)) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull = ndr_pull_init_blob(&blob, r, NULL);
+       if (pull == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull->flags |= LIBNDR_FLAG_REF_ALLOC;
+       ndr_err = call->ndr_pull(pull, NDR_IN, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriverPackagePath, r);
+       }
+
+       ZERO_STRUCT(r->out);
+       r->out.driver_package_cab = r->in.driver_package_cab;
+       r->out.required = talloc_zero(r, uint32_t);
+       if (r->out.required == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       r->out.result = _spoolss_GetPrinterDriverPackagePath(p, r);
+
+       if (p->rng_fault_state) {
+               talloc_free(r);
+               /* Return true here, srv_pipe_hnd.c will take care */
+               return true;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriverPackagePath, r);
+       }
+
+       push = ndr_push_init_ctx(r, NULL);
+       if (push == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       ndr_err = call->ndr_push(push, NDR_OUT, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       blob = ndr_push_blob(push);
+       if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
+               talloc_free(r);
+               return false;
+       }
+
+       talloc_free(r);
+
+       return true;
+}
+
+static bool api_spoolss_69(pipes_struct *p)
+{
+       const struct ndr_interface_call *call;
+       struct ndr_pull *pull;
+       struct ndr_push *push;
+       enum ndr_err_code ndr_err;
+       DATA_BLOB blob;
+       struct spoolss_69 *r;
+
+       call = &ndr_table_spoolss.calls[NDR_SPOOLSS_69];
+
+       r = talloc(talloc_tos(), struct spoolss_69);
+       if (r == NULL) {
+               return false;
+       }
+
+       if (!prs_data_blob(&p->in_data.data, &blob, r)) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull = ndr_pull_init_blob(&blob, r, NULL);
+       if (pull == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull->flags |= LIBNDR_FLAG_REF_ALLOC;
+       ndr_err = call->ndr_pull(pull, NDR_IN, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(spoolss_69, r);
+       }
+
+       r->out.result = _spoolss_69(p, r);
+
+       if (p->rng_fault_state) {
+               talloc_free(r);
+               /* Return true here, srv_pipe_hnd.c will take care */
+               return true;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(spoolss_69, r);
+       }
+
+       push = ndr_push_init_ctx(r, NULL);
+       if (push == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       ndr_err = call->ndr_push(push, NDR_OUT, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       blob = ndr_push_blob(push);
+       if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
+               talloc_free(r);
+               return false;
+       }
+
+       talloc_free(r);
+
+       return true;
+}
+
+static bool api_spoolss_6a(pipes_struct *p)
+{
+       const struct ndr_interface_call *call;
+       struct ndr_pull *pull;
+       struct ndr_push *push;
+       enum ndr_err_code ndr_err;
+       DATA_BLOB blob;
+       struct spoolss_6a *r;
+
+       call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6A];
+
+       r = talloc(talloc_tos(), struct spoolss_6a);
+       if (r == NULL) {
+               return false;
+       }
+
+       if (!prs_data_blob(&p->in_data.data, &blob, r)) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull = ndr_pull_init_blob(&blob, r, NULL);
+       if (pull == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull->flags |= LIBNDR_FLAG_REF_ALLOC;
+       ndr_err = call->ndr_pull(pull, NDR_IN, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(spoolss_6a, r);
+       }
+
+       r->out.result = _spoolss_6a(p, r);
+
+       if (p->rng_fault_state) {
+               talloc_free(r);
+               /* Return true here, srv_pipe_hnd.c will take care */
+               return true;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(spoolss_6a, r);
+       }
+
+       push = ndr_push_init_ctx(r, NULL);
+       if (push == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       ndr_err = call->ndr_push(push, NDR_OUT, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       blob = ndr_push_blob(push);
+       if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
+               talloc_free(r);
+               return false;
+       }
+
+       talloc_free(r);
+
+       return true;
+}
+
+static bool api_spoolss_6b(pipes_struct *p)
+{
+       const struct ndr_interface_call *call;
+       struct ndr_pull *pull;
+       struct ndr_push *push;
+       enum ndr_err_code ndr_err;
+       DATA_BLOB blob;
+       struct spoolss_6b *r;
+
+       call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6B];
+
+       r = talloc(talloc_tos(), struct spoolss_6b);
+       if (r == NULL) {
+               return false;
+       }
+
+       if (!prs_data_blob(&p->in_data.data, &blob, r)) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull = ndr_pull_init_blob(&blob, r, NULL);
+       if (pull == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull->flags |= LIBNDR_FLAG_REF_ALLOC;
+       ndr_err = call->ndr_pull(pull, NDR_IN, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(spoolss_6b, r);
+       }
+
+       r->out.result = _spoolss_6b(p, r);
+
+       if (p->rng_fault_state) {
+               talloc_free(r);
+               /* Return true here, srv_pipe_hnd.c will take care */
+               return true;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(spoolss_6b, r);
+       }
+
+       push = ndr_push_init_ctx(r, NULL);
+       if (push == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       ndr_err = call->ndr_push(push, NDR_OUT, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       blob = ndr_push_blob(push);
+       if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
+               talloc_free(r);
+               return false;
+       }
+
+       talloc_free(r);
+
+       return true;
+}
+
+static bool api_spoolss_6c(pipes_struct *p)
+{
+       const struct ndr_interface_call *call;
+       struct ndr_pull *pull;
+       struct ndr_push *push;
+       enum ndr_err_code ndr_err;
+       DATA_BLOB blob;
+       struct spoolss_6c *r;
+
+       call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6C];
+
+       r = talloc(talloc_tos(), struct spoolss_6c);
+       if (r == NULL) {
+               return false;
+       }
+
+       if (!prs_data_blob(&p->in_data.data, &blob, r)) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull = ndr_pull_init_blob(&blob, r, NULL);
+       if (pull == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull->flags |= LIBNDR_FLAG_REF_ALLOC;
+       ndr_err = call->ndr_pull(pull, NDR_IN, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(spoolss_6c, r);
+       }
+
+       r->out.result = _spoolss_6c(p, r);
+
+       if (p->rng_fault_state) {
+               talloc_free(r);
+               /* Return true here, srv_pipe_hnd.c will take care */
+               return true;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(spoolss_6c, r);
+       }
+
+       push = ndr_push_init_ctx(r, NULL);
+       if (push == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       ndr_err = call->ndr_push(push, NDR_OUT, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       blob = ndr_push_blob(push);
+       if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
+               talloc_free(r);
+               return false;
+       }
+
+       talloc_free(r);
+
+       return true;
+}
+
+static bool api_spoolss_6d(pipes_struct *p)
+{
+       const struct ndr_interface_call *call;
+       struct ndr_pull *pull;
+       struct ndr_push *push;
+       enum ndr_err_code ndr_err;
+       DATA_BLOB blob;
+       struct spoolss_6d *r;
+
+       call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6D];
+
+       r = talloc(talloc_tos(), struct spoolss_6d);
+       if (r == NULL) {
+               return false;
+       }
+
+       if (!prs_data_blob(&p->in_data.data, &blob, r)) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull = ndr_pull_init_blob(&blob, r, NULL);
+       if (pull == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull->flags |= LIBNDR_FLAG_REF_ALLOC;
+       ndr_err = call->ndr_pull(pull, NDR_IN, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(spoolss_6d, r);
+       }
+
+       r->out.result = _spoolss_6d(p, r);
+
+       if (p->rng_fault_state) {
+               talloc_free(r);
+               /* Return true here, srv_pipe_hnd.c will take care */
+               return true;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(spoolss_6d, r);
+       }
+
+       push = ndr_push_init_ctx(r, NULL);
+       if (push == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       ndr_err = call->ndr_push(push, NDR_OUT, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       blob = ndr_push_blob(push);
+       if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
+               talloc_free(r);
+               return false;
+       }
+
+       talloc_free(r);
+
+       return true;
+}
+
+
+/* Tables */
+static struct api_struct api_spoolss_cmds[] = 
+{
+       {"SPOOLSS_ENUMPRINTERS", NDR_SPOOLSS_ENUMPRINTERS, api_spoolss_EnumPrinters},
+       {"SPOOLSS_OPENPRINTER", NDR_SPOOLSS_OPENPRINTER, api_spoolss_OpenPrinter},
+       {"SPOOLSS_SETJOB", NDR_SPOOLSS_SETJOB, api_spoolss_SetJob},
+       {"SPOOLSS_GETJOB", NDR_SPOOLSS_GETJOB, api_spoolss_GetJob},
+       {"SPOOLSS_ENUMJOBS", NDR_SPOOLSS_ENUMJOBS, api_spoolss_EnumJobs},
+       {"SPOOLSS_ADDPRINTER", NDR_SPOOLSS_ADDPRINTER, api_spoolss_AddPrinter},
+       {"SPOOLSS_DELETEPRINTER", NDR_SPOOLSS_DELETEPRINTER, api_spoolss_DeletePrinter},
+       {"SPOOLSS_SETPRINTER", NDR_SPOOLSS_SETPRINTER, api_spoolss_SetPrinter},
+       {"SPOOLSS_GETPRINTER", NDR_SPOOLSS_GETPRINTER, api_spoolss_GetPrinter},
+       {"SPOOLSS_ADDPRINTERDRIVER", NDR_SPOOLSS_ADDPRINTERDRIVER, api_spoolss_AddPrinterDriver},
+       {"SPOOLSS_ENUMPRINTERDRIVERS", NDR_SPOOLSS_ENUMPRINTERDRIVERS, api_spoolss_EnumPrinterDrivers},
+       {"SPOOLSS_GETPRINTERDRIVER", NDR_SPOOLSS_GETPRINTERDRIVER, api_spoolss_GetPrinterDriver},
+       {"SPOOLSS_GETPRINTERDRIVERDIRECTORY", NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY, api_spoolss_GetPrinterDriverDirectory},
+       {"SPOOLSS_DELETEPRINTERDRIVER", NDR_SPOOLSS_DELETEPRINTERDRIVER, api_spoolss_DeletePrinterDriver},
+       {"SPOOLSS_ADDPRINTPROCESSOR", NDR_SPOOLSS_ADDPRINTPROCESSOR, api_spoolss_AddPrintProcessor},
+       {"SPOOLSS_ENUMPRINTPROCESSORS", NDR_SPOOLSS_ENUMPRINTPROCESSORS, api_spoolss_EnumPrintProcessors},
+       {"SPOOLSS_GETPRINTPROCESSORDIRECTORY", NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY, api_spoolss_GetPrintProcessorDirectory},
+       {"SPOOLSS_STARTDOCPRINTER", NDR_SPOOLSS_STARTDOCPRINTER, api_spoolss_StartDocPrinter},
+       {"SPOOLSS_STARTPAGEPRINTER", NDR_SPOOLSS_STARTPAGEPRINTER, api_spoolss_StartPagePrinter},
+       {"SPOOLSS_WRITEPRINTER", NDR_SPOOLSS_WRITEPRINTER, api_spoolss_WritePrinter},
+       {"SPOOLSS_ENDPAGEPRINTER", NDR_SPOOLSS_ENDPAGEPRINTER, api_spoolss_EndPagePrinter},
+       {"SPOOLSS_ABORTPRINTER", NDR_SPOOLSS_ABORTPRINTER, api_spoolss_AbortPrinter},
+       {"SPOOLSS_READPRINTER", NDR_SPOOLSS_READPRINTER, api_spoolss_ReadPrinter},
        {"SPOOLSS_ENDDOCPRINTER", NDR_SPOOLSS_ENDDOCPRINTER, api_spoolss_EndDocPrinter},
        {"SPOOLSS_ADDJOB", NDR_SPOOLSS_ADDJOB, api_spoolss_AddJob},
        {"SPOOLSS_SCHEDULEJOB", NDR_SPOOLSS_SCHEDULEJOB, api_spoolss_ScheduleJob},
@@ -7474,8 +8594,8 @@ static struct api_struct api_spoolss_cmds[] =
        {"SPOOLSS_SPOOLERINIT", NDR_SPOOLSS_SPOOLERINIT, api_spoolss_SpoolerInit},
        {"SPOOLSS_RESETPRINTEREX", NDR_SPOOLSS_RESETPRINTEREX, api_spoolss_ResetPrinterEx},
        {"SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX", NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX, api_spoolss_RemoteFindFirstPrinterChangeNotifyEx},
-       {"SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFICATION", NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFICATION, api_spoolss_RouterRefreshPrinterChangeNotification},
-       {"SPOOLSS_REMOTEFINDNEXTPRINTERCHANGENOTIFYEX", NDR_SPOOLSS_REMOTEFINDNEXTPRINTERCHANGENOTIFYEX, api_spoolss_RemoteFindNextPrinterChangeNotifyEx},
+       {"SPOOLSS_ROUTERREPLYPRINTEREX", NDR_SPOOLSS_ROUTERREPLYPRINTEREX, api_spoolss_RouterReplyPrinterEx},
+       {"SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY", NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY, api_spoolss_RouterRefreshPrinterChangeNotify},
        {"SPOOLSS_44", NDR_SPOOLSS_44, api_spoolss_44},
        {"SPOOLSS_OPENPRINTEREX", NDR_SPOOLSS_OPENPRINTEREX, api_spoolss_OpenPrinterEx},
        {"SPOOLSS_ADDPRINTEREX", NDR_SPOOLSS_ADDPRINTEREX, api_spoolss_AddPrinterEx},
@@ -7504,6 +8624,20 @@ static struct api_struct api_spoolss_cmds[] =
        {"SPOOLSS_5D", NDR_SPOOLSS_5D, api_spoolss_5d},
        {"SPOOLSS_5E", NDR_SPOOLSS_5E, api_spoolss_5e},
        {"SPOOLSS_5F", NDR_SPOOLSS_5F, api_spoolss_5f},
+       {"SPOOLSS_60", NDR_SPOOLSS_60, api_spoolss_60},
+       {"SPOOLSS_61", NDR_SPOOLSS_61, api_spoolss_61},
+       {"SPOOLSS_62", NDR_SPOOLSS_62, api_spoolss_62},
+       {"SPOOLSS_63", NDR_SPOOLSS_63, api_spoolss_63},
+       {"SPOOLSS_64", NDR_SPOOLSS_64, api_spoolss_64},
+       {"SPOOLSS_65", NDR_SPOOLSS_65, api_spoolss_65},
+       {"SPOOLSS_GETCOREPRINTERDRIVERS", NDR_SPOOLSS_GETCOREPRINTERDRIVERS, api_spoolss_GetCorePrinterDrivers},
+       {"SPOOLSS_67", NDR_SPOOLSS_67, api_spoolss_67},
+       {"SPOOLSS_GETPRINTERDRIVERPACKAGEPATH", NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH, api_spoolss_GetPrinterDriverPackagePath},
+       {"SPOOLSS_69", NDR_SPOOLSS_69, api_spoolss_69},
+       {"SPOOLSS_6A", NDR_SPOOLSS_6A, api_spoolss_6a},
+       {"SPOOLSS_6B", NDR_SPOOLSS_6B, api_spoolss_6b},
+       {"SPOOLSS_6C", NDR_SPOOLSS_6C, api_spoolss_6c},
+       {"SPOOLSS_6D", NDR_SPOOLSS_6D, api_spoolss_6d},
 };
 
 void spoolss_get_pipe_fns(struct api_struct **fns, int *n_fns)
@@ -7523,19 +8657,19 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                case NDR_SPOOLSS_ENUMPRINTERS: {
                        struct spoolss_EnumPrinters *r = (struct spoolss_EnumPrinters *)_r;
                        ZERO_STRUCT(r->out);
-                       r->out.info = talloc_zero_array(mem_ctx, union spoolss_PrinterInfo, r->out.count);
+                       r->out.count = talloc_zero(mem_ctx, uint32_t);
+                       if (r->out.count == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
+                       r->out.info = talloc_zero(mem_ctx, union spoolss_PrinterInfo *);
                        if (r->out.info == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.needed = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.needed == NULL) {
-                       return NT_STATUS_NO_MEMORY;
-                       }
-
-                       r->out.count = talloc_zero(mem_ctx, uint32_t);
-                       if (r->out.count == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_EnumPrinters(cli->pipes_struct, r);
@@ -7547,7 +8681,7 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                        ZERO_STRUCT(r->out);
                        r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
                        if (r->out.handle == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_OpenPrinter(cli->pipes_struct, r);
@@ -7565,12 +8699,12 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                        ZERO_STRUCT(r->out);
                        r->out.info = talloc_zero(mem_ctx, union spoolss_JobInfo);
                        if (r->out.info == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.needed = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.needed == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_GetJob(cli->pipes_struct, r);
@@ -7580,19 +8714,19 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                case NDR_SPOOLSS_ENUMJOBS: {
                        struct spoolss_EnumJobs *r = (struct spoolss_EnumJobs *)_r;
                        ZERO_STRUCT(r->out);
-                       r->out.info = talloc_zero_array(mem_ctx, union spoolss_JobInfo, r->out.count);
+                       r->out.count = talloc_zero(mem_ctx, uint32_t);
+                       if (r->out.count == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
+                       r->out.info = talloc_zero(mem_ctx, union spoolss_JobInfo *);
                        if (r->out.info == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.needed = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.needed == NULL) {
-                       return NT_STATUS_NO_MEMORY;
-                       }
-
-                       r->out.count = talloc_zero(mem_ctx, uint32_t);
-                       if (r->out.count == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_EnumJobs(cli->pipes_struct, r);
@@ -7601,6 +8735,12 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 
                case NDR_SPOOLSS_ADDPRINTER: {
                        struct spoolss_AddPrinter *r = (struct spoolss_AddPrinter *)_r;
+                       ZERO_STRUCT(r->out);
+                       r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
+                       if (r->out.handle == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
                        r->out.result = _spoolss_AddPrinter(cli->pipes_struct, r);
                        return NT_STATUS_OK;
                }
@@ -7622,12 +8762,12 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                        ZERO_STRUCT(r->out);
                        r->out.info = talloc_zero(mem_ctx, union spoolss_PrinterInfo);
                        if (r->out.info == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.needed = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.needed == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_GetPrinter(cli->pipes_struct, r);
@@ -7643,19 +8783,19 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                case NDR_SPOOLSS_ENUMPRINTERDRIVERS: {
                        struct spoolss_EnumPrinterDrivers *r = (struct spoolss_EnumPrinterDrivers *)_r;
                        ZERO_STRUCT(r->out);
-                       r->out.info = talloc_zero_array(mem_ctx, union spoolss_DriverInfo, r->out.count);
+                       r->out.count = talloc_zero(mem_ctx, uint32_t);
+                       if (r->out.count == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
+                       r->out.info = talloc_zero(mem_ctx, union spoolss_DriverInfo *);
                        if (r->out.info == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.needed = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.needed == NULL) {
-                       return NT_STATUS_NO_MEMORY;
-                       }
-
-                       r->out.count = talloc_zero(mem_ctx, uint32_t);
-                       if (r->out.count == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_EnumPrinterDrivers(cli->pipes_struct, r);
@@ -7664,6 +8804,17 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 
                case NDR_SPOOLSS_GETPRINTERDRIVER: {
                        struct spoolss_GetPrinterDriver *r = (struct spoolss_GetPrinterDriver *)_r;
+                       ZERO_STRUCT(r->out);
+                       r->out.info = talloc_zero(mem_ctx, union spoolss_DriverInfo);
+                       if (r->out.info == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
+                       r->out.needed = talloc_zero(mem_ctx, uint32_t);
+                       if (r->out.needed == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
                        r->out.result = _spoolss_GetPrinterDriver(cli->pipes_struct, r);
                        return NT_STATUS_OK;
                }
@@ -7673,12 +8824,12 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                        ZERO_STRUCT(r->out);
                        r->out.info = talloc_zero(mem_ctx, union spoolss_DriverDirectoryInfo);
                        if (r->out.info == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.needed = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.needed == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_GetPrinterDriverDirectory(cli->pipes_struct, r);
@@ -7700,19 +8851,19 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                case NDR_SPOOLSS_ENUMPRINTPROCESSORS: {
                        struct spoolss_EnumPrintProcessors *r = (struct spoolss_EnumPrintProcessors *)_r;
                        ZERO_STRUCT(r->out);
-                       r->out.info = talloc_zero_array(mem_ctx, union spoolss_PrintProcessorInfo, r->out.count);
+                       r->out.count = talloc_zero(mem_ctx, uint32_t);
+                       if (r->out.count == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
+                       r->out.info = talloc_zero(mem_ctx, union spoolss_PrintProcessorInfo *);
                        if (r->out.info == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.needed = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.needed == NULL) {
-                       return NT_STATUS_NO_MEMORY;
-                       }
-
-                       r->out.count = talloc_zero(mem_ctx, uint32_t);
-                       if (r->out.count == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_EnumPrintProcessors(cli->pipes_struct, r);
@@ -7721,6 +8872,17 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 
                case NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY: {
                        struct spoolss_GetPrintProcessorDirectory *r = (struct spoolss_GetPrintProcessorDirectory *)_r;
+                       ZERO_STRUCT(r->out);
+                       r->out.info = talloc_zero(mem_ctx, union spoolss_PrintProcessorDirectoryInfo);
+                       if (r->out.info == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
+                       r->out.needed = talloc_zero(mem_ctx, uint32_t);
+                       if (r->out.needed == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
                        r->out.result = _spoolss_GetPrintProcessorDirectory(cli->pipes_struct, r);
                        return NT_STATUS_OK;
                }
@@ -7730,7 +8892,7 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                        ZERO_STRUCT(r->out);
                        r->out.job_id = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.job_id == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_StartDocPrinter(cli->pipes_struct, r);
@@ -7748,7 +8910,7 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                        ZERO_STRUCT(r->out);
                        r->out.num_written = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.num_written == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_WritePrinter(cli->pipes_struct, r);
@@ -7770,14 +8932,14 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                case NDR_SPOOLSS_READPRINTER: {
                        struct spoolss_ReadPrinter *r = (struct spoolss_ReadPrinter *)_r;
                        ZERO_STRUCT(r->out);
-                       r->out.data = talloc_zero(mem_ctx, DATA_BLOB);
+                       r->out.data = talloc_zero_array(mem_ctx, uint8_t, r->in.data_size);
                        if (r->out.data == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out._data_size = talloc_zero(mem_ctx, uint32_t);
                        if (r->out._data_size == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_ReadPrinter(cli->pipes_struct, r);
@@ -7792,6 +8954,13 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 
                case NDR_SPOOLSS_ADDJOB: {
                        struct spoolss_AddJob *r = (struct spoolss_AddJob *)_r;
+                       ZERO_STRUCT(r->out);
+                       r->out.buffer = r->in.buffer;
+                       r->out.needed = talloc_zero(mem_ctx, uint32_t);
+                       if (r->out.needed == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
                        r->out.result = _spoolss_AddJob(cli->pipes_struct, r);
                        return NT_STATUS_OK;
                }
@@ -7805,19 +8974,19 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                case NDR_SPOOLSS_GETPRINTERDATA: {
                        struct spoolss_GetPrinterData *r = (struct spoolss_GetPrinterData *)_r;
                        ZERO_STRUCT(r->out);
-                       r->out.type = talloc_zero(mem_ctx, enum spoolss_PrinterDataType);
+                       r->out.type = talloc_zero(mem_ctx, enum winreg_Type);
                        if (r->out.type == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
-                       r->out.data = talloc_zero(mem_ctx, union spoolss_PrinterData);
+                       r->out.data = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
                        if (r->out.data == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.needed = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.needed == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_GetPrinterData(cli->pipes_struct, r);
@@ -7861,12 +9030,12 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                        ZERO_STRUCT(r->out);
                        r->out.info = talloc_zero(mem_ctx, union spoolss_FormInfo);
                        if (r->out.info == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.needed = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.needed == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_GetForm(cli->pipes_struct, r);
@@ -7882,19 +9051,19 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                case NDR_SPOOLSS_ENUMFORMS: {
                        struct spoolss_EnumForms *r = (struct spoolss_EnumForms *)_r;
                        ZERO_STRUCT(r->out);
-                       r->out.info = talloc_zero_array(mem_ctx, union spoolss_FormInfo, r->out.count);
+                       r->out.count = talloc_zero(mem_ctx, uint32_t);
+                       if (r->out.count == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
+                       r->out.info = talloc_zero(mem_ctx, union spoolss_FormInfo *);
                        if (r->out.info == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.needed = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.needed == NULL) {
-                       return NT_STATUS_NO_MEMORY;
-                       }
-
-                       r->out.count = talloc_zero(mem_ctx, uint32_t);
-                       if (r->out.count == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_EnumForms(cli->pipes_struct, r);
@@ -7904,19 +9073,19 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                case NDR_SPOOLSS_ENUMPORTS: {
                        struct spoolss_EnumPorts *r = (struct spoolss_EnumPorts *)_r;
                        ZERO_STRUCT(r->out);
-                       r->out.info = talloc_zero_array(mem_ctx, union spoolss_PortInfo, r->out.count);
+                       r->out.count = talloc_zero(mem_ctx, uint32_t);
+                       if (r->out.count == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
+                       r->out.info = talloc_zero(mem_ctx, union spoolss_PortInfo *);
                        if (r->out.info == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.needed = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.needed == NULL) {
-                       return NT_STATUS_NO_MEMORY;
-                       }
-
-                       r->out.count = talloc_zero(mem_ctx, uint32_t);
-                       if (r->out.count == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_EnumPorts(cli->pipes_struct, r);
@@ -7926,19 +9095,19 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                case NDR_SPOOLSS_ENUMMONITORS: {
                        struct spoolss_EnumMonitors *r = (struct spoolss_EnumMonitors *)_r;
                        ZERO_STRUCT(r->out);
-                       r->out.info = talloc_zero_array(mem_ctx, union spoolss_MonitorInfo, r->out.count);
+                       r->out.count = talloc_zero(mem_ctx, uint32_t);
+                       if (r->out.count == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
+                       r->out.info = talloc_zero(mem_ctx, union spoolss_MonitorInfo *);
                        if (r->out.info == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.needed = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.needed == NULL) {
-                       return NT_STATUS_NO_MEMORY;
-                       }
-
-                       r->out.count = talloc_zero(mem_ctx, uint32_t);
-                       if (r->out.count == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_EnumMonitors(cli->pipes_struct, r);
@@ -7965,6 +9134,12 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 
                case NDR_SPOOLSS_CREATEPRINTERIC: {
                        struct spoolss_CreatePrinterIC *r = (struct spoolss_CreatePrinterIC *)_r;
+                       ZERO_STRUCT(r->out);
+                       r->out.gdi_handle = talloc_zero(mem_ctx, struct policy_handle);
+                       if (r->out.gdi_handle == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
                        r->out.result = _spoolss_CreatePrinterIC(cli->pipes_struct, r);
                        return NT_STATUS_OK;
                }
@@ -7977,6 +9152,8 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 
                case NDR_SPOOLSS_DELETEPRINTERIC: {
                        struct spoolss_DeletePrinterIC *r = (struct spoolss_DeletePrinterIC *)_r;
+                       ZERO_STRUCT(r->out);
+                       r->out.gdi_handle = r->in.gdi_handle;
                        r->out.result = _spoolss_DeletePrinterIC(cli->pipes_struct, r);
                        return NT_STATUS_OK;
                }
@@ -8031,6 +9208,22 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 
                case NDR_SPOOLSS_ENUMPRINTPROCDATATYPES: {
                        struct spoolss_EnumPrintProcDataTypes *r = (struct spoolss_EnumPrintProcDataTypes *)_r;
+                       ZERO_STRUCT(r->out);
+                       r->out.count = talloc_zero(mem_ctx, uint32_t);
+                       if (r->out.count == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
+                       r->out.info = talloc_zero(mem_ctx, union spoolss_PrintProcDataTypesInfo *);
+                       if (r->out.info == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
+                       r->out.needed = talloc_zero(mem_ctx, uint32_t);
+                       if (r->out.needed == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
                        r->out.result = _spoolss_EnumPrintProcDataTypes(cli->pipes_struct, r);
                        return NT_STATUS_OK;
                }
@@ -8044,24 +9237,24 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                case NDR_SPOOLSS_GETPRINTERDRIVER2: {
                        struct spoolss_GetPrinterDriver2 *r = (struct spoolss_GetPrinterDriver2 *)_r;
                        ZERO_STRUCT(r->out);
-                       r->out.info = talloc_zero(mem_ctx, DATA_BLOB);
+                       r->out.info = talloc_zero(mem_ctx, union spoolss_DriverInfo);
                        if (r->out.info == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.needed = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.needed == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.server_major_version = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.server_major_version == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.server_minor_version = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.server_minor_version == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_GetPrinterDriver2(cli->pipes_struct, r);
@@ -8097,7 +9290,7 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                        ZERO_STRUCT(r->out);
                        r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
                        if (r->out.handle == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_ReplyOpenPrinter(cli->pipes_struct, r);
@@ -8148,21 +9341,27 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                        return NT_STATUS_OK;
                }
 
-               case NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFICATION: {
-                       struct spoolss_RouterRefreshPrinterChangeNotification *r = (struct spoolss_RouterRefreshPrinterChangeNotification *)_r;
-                       r->out.result = _spoolss_RouterRefreshPrinterChangeNotification(cli->pipes_struct, r);
+               case NDR_SPOOLSS_ROUTERREPLYPRINTEREX: {
+                       struct spoolss_RouterReplyPrinterEx *r = (struct spoolss_RouterReplyPrinterEx *)_r;
+                       ZERO_STRUCT(r->out);
+                       r->out.reply_result = talloc_zero(mem_ctx, uint32_t);
+                       if (r->out.reply_result == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
+                       r->out.result = _spoolss_RouterReplyPrinterEx(cli->pipes_struct, r);
                        return NT_STATUS_OK;
                }
 
-               case NDR_SPOOLSS_REMOTEFINDNEXTPRINTERCHANGENOTIFYEX: {
-                       struct spoolss_RemoteFindNextPrinterChangeNotifyEx *r = (struct spoolss_RemoteFindNextPrinterChangeNotifyEx *)_r;
+               case NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY: {
+                       struct spoolss_RouterRefreshPrinterChangeNotify *r = (struct spoolss_RouterRefreshPrinterChangeNotify *)_r;
                        ZERO_STRUCT(r->out);
                        r->out.info = talloc_zero(mem_ctx, struct spoolss_NotifyInfo *);
                        if (r->out.info == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
-                       r->out.result = _spoolss_RemoteFindNextPrinterChangeNotifyEx(cli->pipes_struct, r);
+                       r->out.result = _spoolss_RouterRefreshPrinterChangeNotify(cli->pipes_struct, r);
                        return NT_STATUS_OK;
                }
 
@@ -8177,7 +9376,7 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                        ZERO_STRUCT(r->out);
                        r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
                        if (r->out.handle == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_OpenPrinterEx(cli->pipes_struct, r);
@@ -8186,6 +9385,12 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 
                case NDR_SPOOLSS_ADDPRINTEREX: {
                        struct spoolss_AddPrinterEx *r = (struct spoolss_AddPrinterEx *)_r;
+                       ZERO_STRUCT(r->out);
+                       r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
+                       if (r->out.handle == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
                        r->out.result = _spoolss_AddPrinterEx(cli->pipes_struct, r);
                        return NT_STATUS_OK;
                }
@@ -8201,27 +9406,27 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                        ZERO_STRUCT(r->out);
                        r->out.value_name = talloc_zero_array(mem_ctx, const char, r->in.value_offered / 2);
                        if (r->out.value_name == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.value_needed = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.value_needed == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
-                       r->out.printerdata_type = talloc_zero(mem_ctx, uint32_t);
-                       if (r->out.printerdata_type == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                       r->out.type = talloc_zero(mem_ctx, enum winreg_Type);
+                       if (r->out.type == NULL) {
+                               return NT_STATUS_NO_MEMORY;
                        }
 
-                       r->out.buffer = talloc_zero(mem_ctx, DATA_BLOB);
-                       if (r->out.buffer == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                       r->out.data = talloc_zero_array(mem_ctx, uint8_t, r->in.data_offered);
+                       if (r->out.data == NULL) {
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.data_needed = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.data_needed == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_EnumPrinterData(cli->pipes_struct, r);
@@ -8261,19 +9466,19 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                case NDR_SPOOLSS_GETPRINTERDATAEX: {
                        struct spoolss_GetPrinterDataEx *r = (struct spoolss_GetPrinterDataEx *)_r;
                        ZERO_STRUCT(r->out);
-                       r->out.type = talloc_zero(mem_ctx, uint32_t);
+                       r->out.type = talloc_zero(mem_ctx, enum winreg_Type);
                        if (r->out.type == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
-                       r->out.buffer = talloc_zero(mem_ctx, DATA_BLOB);
-                       if (r->out.buffer == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                       r->out.data = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
+                       if (r->out.data == NULL) {
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.needed = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.needed == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_GetPrinterDataEx(cli->pipes_struct, r);
@@ -8283,19 +9488,19 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                case NDR_SPOOLSS_ENUMPRINTERDATAEX: {
                        struct spoolss_EnumPrinterDataEx *r = (struct spoolss_EnumPrinterDataEx *)_r;
                        ZERO_STRUCT(r->out);
-                       r->out.buffer = talloc_zero(mem_ctx, DATA_BLOB);
-                       if (r->out.buffer == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                       r->out.count = talloc_zero(mem_ctx, uint32_t);
+                       if (r->out.count == NULL) {
+                               return NT_STATUS_NO_MEMORY;
                        }
 
-                       r->out.needed = talloc_zero(mem_ctx, uint32_t);
-                       if (r->out.needed == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                       r->out.info = talloc_zero(mem_ctx, struct spoolss_PrinterEnumValues *);
+                       if (r->out.info == NULL) {
+                               return NT_STATUS_NO_MEMORY;
                        }
 
-                       r->out.count = talloc_zero(mem_ctx, uint32_t);
-                       if (r->out.count == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                       r->out.needed = talloc_zero(mem_ctx, uint32_t);
+                       if (r->out.needed == NULL) {
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_EnumPrinterDataEx(cli->pipes_struct, r);
@@ -8305,15 +9510,19 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                case NDR_SPOOLSS_ENUMPRINTERKEY: {
                        struct spoolss_EnumPrinterKey *r = (struct spoolss_EnumPrinterKey *)_r;
                        ZERO_STRUCT(r->out);
-                       r->out.needed = r->in.needed;
-                       r->out.key_buffer_size = talloc_zero(mem_ctx, uint32_t);
-                       if (r->out.key_buffer_size == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                       r->out._ndr_size = talloc_zero(mem_ctx, uint32_t);
+                       if (r->out._ndr_size == NULL) {
+                               return NT_STATUS_NO_MEMORY;
                        }
 
-                       r->out.key_buffer = talloc_zero_array(mem_ctx, uint16_t, r->out.key_buffer_size);
+                       r->out.key_buffer = talloc_zero(mem_ctx, union spoolss_KeyNames);
                        if (r->out.key_buffer == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
+                       r->out.needed = talloc_zero(mem_ctx, uint32_t);
+                       if (r->out.needed == NULL) {
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_EnumPrinterKey(cli->pipes_struct, r);
@@ -8365,19 +9574,15 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                case NDR_SPOOLSS_XCVDATA: {
                        struct spoolss_XcvData *r = (struct spoolss_XcvData *)_r;
                        ZERO_STRUCT(r->out);
-                       r->out.out_data = talloc_zero(mem_ctx, DATA_BLOB);
+                       r->out.status_code = r->in.status_code;
+                       r->out.out_data = talloc_zero_array(mem_ctx, uint8_t, r->in.out_data_size);
                        if (r->out.out_data == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.needed = talloc_zero(mem_ctx, uint32_t);
                        if (r->out.needed == NULL) {
-                       return NT_STATUS_NO_MEMORY;
-                       }
-
-                       r->out.unknown2 = talloc_zero(mem_ctx, uint32_t);
-                       if (r->out.unknown2 == NULL) {
-                       return NT_STATUS_NO_MEMORY;
+                               return NT_STATUS_NO_MEMORY;
                        }
 
                        r->out.result = _spoolss_XcvData(cli->pipes_struct, r);
@@ -8426,6 +9631,103 @@ NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                        return NT_STATUS_OK;
                }
 
+               case NDR_SPOOLSS_60: {
+                       struct spoolss_60 *r = (struct spoolss_60 *)_r;
+                       r->out.result = _spoolss_60(cli->pipes_struct, r);
+                       return NT_STATUS_OK;
+               }
+
+               case NDR_SPOOLSS_61: {
+                       struct spoolss_61 *r = (struct spoolss_61 *)_r;
+                       r->out.result = _spoolss_61(cli->pipes_struct, r);
+                       return NT_STATUS_OK;
+               }
+
+               case NDR_SPOOLSS_62: {
+                       struct spoolss_62 *r = (struct spoolss_62 *)_r;
+                       r->out.result = _spoolss_62(cli->pipes_struct, r);
+                       return NT_STATUS_OK;
+               }
+
+               case NDR_SPOOLSS_63: {
+                       struct spoolss_63 *r = (struct spoolss_63 *)_r;
+                       r->out.result = _spoolss_63(cli->pipes_struct, r);
+                       return NT_STATUS_OK;
+               }
+
+               case NDR_SPOOLSS_64: {
+                       struct spoolss_64 *r = (struct spoolss_64 *)_r;
+                       r->out.result = _spoolss_64(cli->pipes_struct, r);
+                       return NT_STATUS_OK;
+               }
+
+               case NDR_SPOOLSS_65: {
+                       struct spoolss_65 *r = (struct spoolss_65 *)_r;
+                       r->out.result = _spoolss_65(cli->pipes_struct, r);
+                       return NT_STATUS_OK;
+               }
+
+               case NDR_SPOOLSS_GETCOREPRINTERDRIVERS: {
+                       struct spoolss_GetCorePrinterDrivers *r = (struct spoolss_GetCorePrinterDrivers *)_r;
+                       ZERO_STRUCT(r->out);
+                       r->out.core_printer_drivers = talloc_zero_array(mem_ctx, struct spoolss_CorePrinterDriver, r->in.core_printer_driver_count);
+                       if (r->out.core_printer_drivers == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
+                       r->out.result = _spoolss_GetCorePrinterDrivers(cli->pipes_struct, r);
+                       return NT_STATUS_OK;
+               }
+
+               case NDR_SPOOLSS_67: {
+                       struct spoolss_67 *r = (struct spoolss_67 *)_r;
+                       r->out.result = _spoolss_67(cli->pipes_struct, r);
+                       return NT_STATUS_OK;
+               }
+
+               case NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH: {
+                       struct spoolss_GetPrinterDriverPackagePath *r = (struct spoolss_GetPrinterDriverPackagePath *)_r;
+                       ZERO_STRUCT(r->out);
+                       r->out.driver_package_cab = r->in.driver_package_cab;
+                       r->out.required = talloc_zero(mem_ctx, uint32_t);
+                       if (r->out.required == NULL) {
+                               return NT_STATUS_NO_MEMORY;
+                       }
+
+                       r->out.result = _spoolss_GetPrinterDriverPackagePath(cli->pipes_struct, r);
+                       return NT_STATUS_OK;
+               }
+
+               case NDR_SPOOLSS_69: {
+                       struct spoolss_69 *r = (struct spoolss_69 *)_r;
+                       r->out.result = _spoolss_69(cli->pipes_struct, r);
+                       return NT_STATUS_OK;
+               }
+
+               case NDR_SPOOLSS_6A: {
+                       struct spoolss_6a *r = (struct spoolss_6a *)_r;
+                       r->out.result = _spoolss_6a(cli->pipes_struct, r);
+                       return NT_STATUS_OK;
+               }
+
+               case NDR_SPOOLSS_6B: {
+                       struct spoolss_6b *r = (struct spoolss_6b *)_r;
+                       r->out.result = _spoolss_6b(cli->pipes_struct, r);
+                       return NT_STATUS_OK;
+               }
+
+               case NDR_SPOOLSS_6C: {
+                       struct spoolss_6c *r = (struct spoolss_6c *)_r;
+                       r->out.result = _spoolss_6c(cli->pipes_struct, r);
+                       return NT_STATUS_OK;
+               }
+
+               case NDR_SPOOLSS_6D: {
+                       struct spoolss_6d *r = (struct spoolss_6d *)_r;
+                       r->out.result = _spoolss_6d(cli->pipes_struct, r);
+                       return NT_STATUS_OK;
+               }
+
                default:
                        return NT_STATUS_NOT_IMPLEMENTED;
        }