librpc/gen_ndr/ndr_spoolss.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_spoolss.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_winreg.h"
   9 static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Time *r)
  10 {
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 2));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
  14                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
  15                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day_of_week));
  16                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
  17                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
  18                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
  19                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
  20                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
  21         }
  22         if (ndr_flags & NDR_BUFFERS) {
  23         }
  24         return NDR_ERR_SUCCESS;
  25 }
  26
  27 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  28 {
  29         if (ndr_flags & NDR_SCALARS) {
  30                 NDR_CHECK(ndr_pull_align(ndr, 2));
  31                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  39         }
  40         if (ndr_flags & NDR_BUFFERS) {
  41         }
  42         return NDR_ERR_SUCCESS;
  43 }
  44
  45 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  46 {
  47         ndr_print_struct(ndr, name, "spoolss_Time");
  48         ndr->depth++;
  49         ndr_print_uint16(ndr, "year", r->year);
  50         ndr_print_uint16(ndr, "month", r->month);
  51         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  52         ndr_print_uint16(ndr, "day", r->day);
  53         ndr_print_uint16(ndr, "hour", r->hour);
  54         ndr_print_uint16(ndr, "minute", r->minute);
  55         ndr_print_uint16(ndr, "second", r->second);
  56         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  57         ndr->depth--;
  58 }
  59
  60 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  61 {
  62         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  63 }
  64
  65 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  66 {
  67         if (ndr_flags & NDR_SCALARS) {
  68                 NDR_CHECK(ndr_push_align(ndr, 4));
  69                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  70                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  71         }
  72         if (ndr_flags & NDR_BUFFERS) {
  73                 if (r->time) {
  74                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  75                 }
  76         }
  77         return NDR_ERR_SUCCESS;
  78 }
  79
  80 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  81 {
  82         uint32_t _ptr_time;
  83         TALLOC_CTX *_mem_save_time_0;
  84         if (ndr_flags & NDR_SCALARS) {
  85                 NDR_CHECK(ndr_pull_align(ndr, 4));
  86                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  87                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  88                 if (_ptr_time) {
  89                         NDR_PULL_ALLOC(ndr, r->time);
  90                 } else {
  91                         r->time = NULL;
  92                 }
  93         }
  94         if (ndr_flags & NDR_BUFFERS) {
  95                 if (r->time) {
  96                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
  97                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
  98                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
  99                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 100                 }
 101         }
 102         return NDR_ERR_SUCCESS;
 103 }
 104
 105 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 106 {
 107         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 108         ndr->depth++;
 109         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 110         ndr_print_ptr(ndr, "time", r->time);
 111         ndr->depth++;
 112         if (r->time) {
 113                 ndr_print_spoolss_Time(ndr, "time", r->time);
 114         }
 115         ndr->depth--;
 116         ndr->depth--;
 117 }
 118
 119 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 120 {
 121         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 122         return NDR_ERR_SUCCESS;
 123 }
 124
 125 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 126 {
 127         uint16_t v;
 128         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 129         *r = v;
 130         return NDR_ERR_SUCCESS;
 131 }
 132
 133 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 134 {
 135         const char *val = NULL;
 136
 137         switch (r) {
 138                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 139                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 140                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 141         }
 142         ndr_print_enum(ndr, name, "ENUM", val, r);
 143 }
 144
 145 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 146 {
 147         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 148         return NDR_ERR_SUCCESS;
 149 }
 150
 151 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 152 {
 153         uint32_t v;
 154         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 155         *r = v;
 156         return NDR_ERR_SUCCESS;
 157 }
 158
 159 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 160 {
 161         const char *val = NULL;
 162
 163         switch (r) {
 164                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 165                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 166                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 167                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 168                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 169         }
 170         ndr_print_enum(ndr, name, "ENUM", val, r);
 171 }
 172
 173 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 174 {
 175         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 176         return NDR_ERR_SUCCESS;
 177 }
 178
 179 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 180 {
 181         uint32_t v;
 182         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 183         *r = v;
 184         return NDR_ERR_SUCCESS;
 185 }
 186
 187 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 188 {
 189         const char *val = NULL;
 190
 191         switch (r) {
 192                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 193                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 194                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 195         }
 196         ndr_print_enum(ndr, name, "ENUM", val, r);
 197 }
 198
 199 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 200 {
 201         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 202         return NDR_ERR_SUCCESS;
 203 }
 204
 205 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 206 {
 207         uint32_t v;
 208         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 209         *r = v;
 210         return NDR_ERR_SUCCESS;
 211 }
 212
 213 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 214 {
 215         const char *val = NULL;
 216
 217         switch (r) {
 218                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 219                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 220                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 221                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 222                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 223         }
 224         ndr_print_enum(ndr, name, "ENUM", val, r);
 225 }
 226
 227 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 228 {
 229         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 230         return NDR_ERR_SUCCESS;
 231 }
 232
 233 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 234 {
 235         uint32_t v;
 236         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 237         *r = v;
 238         return NDR_ERR_SUCCESS;
 239 }
 240
 241 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 242 {
 243         ndr_print_uint32(ndr, name, r);
 244         ndr->depth++;
 245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 246         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 247         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 248         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 259         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 270         ndr->depth--;
 271 }
 272
 273 static enum ndr_err_code ndr_push_spoolss_JobStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 274 {
 275         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 276         return NDR_ERR_SUCCESS;
 277 }
 278
 279 static enum ndr_err_code ndr_pull_spoolss_JobStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 280 {
 281         uint32_t v;
 282         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 283         *r = v;
 284         return NDR_ERR_SUCCESS;
 285 }
 286
 287 _PUBLIC_ void ndr_print_spoolss_JobStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 288 {
 289         ndr_print_uint32(ndr, name, r);
 290         ndr->depth++;
 291         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAUSED", JOB_STATUS_PAUSED, r);
 292         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_ERROR", JOB_STATUS_ERROR, r);
 293         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETING", JOB_STATUS_DELETING, r);
 294         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_SPOOLING", JOB_STATUS_SPOOLING, r);
 295         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTING", JOB_STATUS_PRINTING, r);
 296         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_OFFLINE", JOB_STATUS_OFFLINE, r);
 297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAPEROUT", JOB_STATUS_PAPEROUT, r);
 298         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTED", JOB_STATUS_PRINTED, r);
 299         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETED", JOB_STATUS_DELETED, r);
 300         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_BLOCKED_DEVQ", JOB_STATUS_BLOCKED_DEVQ, r);
 301         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_USER_INTERVENTION", JOB_STATUS_USER_INTERVENTION, r);
 302         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_RESTART", JOB_STATUS_RESTART, r);
 303         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_COMPLETE", JOB_STATUS_COMPLETE, r);
 304         ndr->depth--;
 305 }
 306
 307 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 308 {
 309         if (ndr_flags & NDR_SCALARS) {
 310                 NDR_CHECK(ndr_push_align(ndr, 4));
 311                 {
 312                         uint32_t _flags_save_string = ndr->flags;
 313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 314                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 315                         ndr->flags = _flags_save_string;
 316                 }
 317                 {
 318                         uint32_t _flags_save_string = ndr->flags;
 319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 320                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 321                         ndr->flags = _flags_save_string;
 322                 }
 323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 326                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 336                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->job_error));
 337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 338                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 341                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 342                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
 343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 345                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 346                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 350         }
 351         if (ndr_flags & NDR_BUFFERS) {
 352                 {
 353                         uint32_t _flags_save_string = ndr->flags;
 354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 355                         if (r->printername) {
 356                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
 357                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 358                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
 359                         }
 360                         ndr->flags = _flags_save_string;
 361                 }
 362                 {
 363                         uint32_t _flags_save_string = ndr->flags;
 364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 365                         if (r->servername) {
 366                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->servername));
 367                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 368                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->servername));
 369                         }
 370                         ndr->flags = _flags_save_string;
 371                 }
 372         }
 373         return NDR_ERR_SUCCESS;
 374 }
 375
 376 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 377 {
 378         uint32_t _ptr_printername;
 379         TALLOC_CTX *_mem_save_printername_0;
 380         uint32_t _ptr_servername;
 381         TALLOC_CTX *_mem_save_servername_0;
 382         if (ndr_flags & NDR_SCALARS) {
 383                 NDR_CHECK(ndr_pull_align(ndr, 4));
 384                 {
 385                         uint32_t _flags_save_string = ndr->flags;
 386                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 387                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 388                         if (_ptr_printername) {
 389                                 NDR_PULL_ALLOC(ndr, r->printername);
 390                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 391                         } else {
 392                                 r->printername = NULL;
 393                         }
 394                         ndr->flags = _flags_save_string;
 395                 }
 396                 {
 397                         uint32_t _flags_save_string = ndr->flags;
 398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 399                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 400                         if (_ptr_servername) {
 401                                 NDR_PULL_ALLOC(ndr, r->servername);
 402                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 403                         } else {
 404                                 r->servername = NULL;
 405                         }
 406                         ndr->flags = _flags_save_string;
 407                 }
 408                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 409                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 411                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 421                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 423                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 424                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 426                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 427                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 428                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 429                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 430                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 431                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 434                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 435         }
 436         if (ndr_flags & NDR_BUFFERS) {
 437                 {
 438                         uint32_t _flags_save_string = ndr->flags;
 439                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 440                         if (r->printername) {
 441                                 uint32_t _relative_save_offset;
 442                                 _relative_save_offset = ndr->offset;
 443                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 444                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 445                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 446                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 447                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 448                                 ndr->offset = _relative_save_offset;
 449                         }
 450                         ndr->flags = _flags_save_string;
 451                 }
 452                 {
 453                         uint32_t _flags_save_string = ndr->flags;
 454                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 455                         if (r->servername) {
 456                                 uint32_t _relative_save_offset;
 457                                 _relative_save_offset = ndr->offset;
 458                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 459                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 460                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 461                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 462                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 463                                 ndr->offset = _relative_save_offset;
 464                         }
 465                         ndr->flags = _flags_save_string;
 466                 }
 467         }
 468         return NDR_ERR_SUCCESS;
 469 }
 470
 471 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 472 {
 473         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 474         ndr->depth++;
 475         ndr_print_ptr(ndr, "printername", r->printername);
 476         ndr->depth++;
 477         if (r->printername) {
 478                 ndr_print_string(ndr, "printername", r->printername);
 479         }
 480         ndr->depth--;
 481         ndr_print_ptr(ndr, "servername", r->servername);
 482         ndr->depth++;
 483         if (r->servername) {
 484                 ndr_print_string(ndr, "servername", r->servername);
 485         }
 486         ndr->depth--;
 487         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 488         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 489         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 490         ndr_print_spoolss_Time(ndr, "time", &r->time);
 491         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 492         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 493         ndr_print_uint32(ndr, "version", r->version);
 494         ndr_print_uint32(ndr, "free_build", r->free_build);
 495         ndr_print_uint32(ndr, "spooling", r->spooling);
 496         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 497         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 498         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 499         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 500         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 501         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 502         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 503         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 504         ndr_print_uint32(ndr, "change_id", r->change_id);
 505         ndr_print_WERROR(ndr, "last_error", r->last_error);
 506         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 507         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 508         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 509         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 510         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 511         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 512         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 513         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 514         ndr->depth--;
 515 }
 516
 517 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo0(const struct spoolss_PrinterInfo0 *r, struct smb_iconv_convenience *ic, int flags)
 518 {
 519         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo0, ic);
 520 }
 521
 522 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 523 {
 524         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 525         return NDR_ERR_SUCCESS;
 526 }
 527
 528 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 529 {
 530         uint32_t v;
 531         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 532         *r = v;
 533         return NDR_ERR_SUCCESS;
 534 }
 535
 536 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 537 {
 538         ndr_print_uint32(ndr, name, r);
 539         ndr->depth++;
 540         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 541         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 542         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 543         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 544         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 545         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 546         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 561         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 562         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 563         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 564         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 565         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 566         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 567         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 568         ndr->depth--;
 569 }
 570
 571 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
 572 {
 573         if (ndr_flags & NDR_SCALARS) {
 574                 NDR_CHECK(ndr_push_align(ndr, 4));
 575                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 576                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->specversion));
 577                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
 578                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 579                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
 580                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
 581                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->orientation));
 582                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->papersize));
 583                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
 584                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
 585                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
 586                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
 587                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->defaultsource));
 588                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->printquality));
 589                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->color));
 590                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->duplex));
 591                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
 592                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ttoption));
 593                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->collate));
 594                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 32, sizeof(uint16_t), CH_UTF16));
 595                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
 596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
 597                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
 598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
 599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayflags));
 600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
 601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmmethod));
 602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmintent));
 603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mediatype));
 604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dithertype));
 605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
 606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 607                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
 608                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
 609                 {
 610                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 611                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 612                         {
 613                                 struct ndr_push *_ndr_driverextra_data;
 614                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
 615                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
 616                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
 617                         }
 618                         ndr->flags = _flags_save_DATA_BLOB;
 619                 }
 620         }
 621         if (ndr_flags & NDR_BUFFERS) {
 622         }
 623         return NDR_ERR_SUCCESS;
 624 }
 625
 626 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
 627 {
 628         if (ndr_flags & NDR_SCALARS) {
 629                 NDR_CHECK(ndr_pull_align(ndr, 4));
 630                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 631                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->specversion));
 632                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
 633                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 634                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
 635                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
 636                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->orientation));
 637                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->papersize));
 638                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
 639                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
 640                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
 641                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
 642                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->defaultsource));
 643                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->printquality));
 644                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->color));
 645                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->duplex));
 646                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
 647                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ttoption));
 648                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->collate));
 649                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 32, sizeof(uint16_t), CH_UTF16));
 650                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
 651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
 652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
 653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
 654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayflags));
 655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
 656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmmethod));
 657                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmintent));
 658                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mediatype));
 659                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dithertype));
 660                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 661                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 662                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
 663                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
 664                 {
 665                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 667                         {
 668                                 struct ndr_pull *_ndr_driverextra_data;
 669                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
 670                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
 671                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
 672                         }
 673                         ndr->flags = _flags_save_DATA_BLOB;
 674                 }
 675         }
 676         if (ndr_flags & NDR_BUFFERS) {
 677         }
 678         return NDR_ERR_SUCCESS;
 679 }
 680
 681 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
 682 {
 683         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
 684         ndr->depth++;
 685         ndr_print_string(ndr, "devicename", r->devicename);
 686         ndr_print_uint16(ndr, "specversion", r->specversion);
 687         ndr_print_uint16(ndr, "driverversion", r->driverversion);
 688         ndr_print_uint16(ndr, "size", r->size);
 689         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
 690         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
 691         ndr_print_uint16(ndr, "orientation", r->orientation);
 692         ndr_print_uint16(ndr, "papersize", r->papersize);
 693         ndr_print_uint16(ndr, "paperlength", r->paperlength);
 694         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
 695         ndr_print_uint16(ndr, "scale", r->scale);
 696         ndr_print_uint16(ndr, "copies", r->copies);
 697         ndr_print_uint16(ndr, "defaultsource", r->defaultsource);
 698         ndr_print_uint16(ndr, "printquality", r->printquality);
 699         ndr_print_uint16(ndr, "color", r->color);
 700         ndr_print_uint16(ndr, "duplex", r->duplex);
 701         ndr_print_uint16(ndr, "yresolution", r->yresolution);
 702         ndr_print_uint16(ndr, "ttoption", r->ttoption);
 703         ndr_print_uint16(ndr, "collate", r->collate);
 704         ndr_print_string(ndr, "formname", r->formname);
 705         ndr_print_uint16(ndr, "logpixels", r->logpixels);
 706         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
 707         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
 708         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
 709         ndr_print_uint32(ndr, "displayflags", r->displayflags);
 710         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
 711         ndr_print_uint32(ndr, "icmmethod", r->icmmethod);
 712         ndr_print_uint32(ndr, "icmintent", r->icmintent);
 713         ndr_print_uint32(ndr, "mediatype", r->mediatype);
 714         ndr_print_uint32(ndr, "dithertype", r->dithertype);
 715         ndr_print_uint32(ndr, "reserved1", r->reserved1);
 716         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 717         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
 718         ndr_print_uint32(ndr, "panningheight", r->panningheight);
 719         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
 720         ndr->depth--;
 721 }
 722
 723 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
 724 {
 725         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
 726 }
 727
 728 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 729 {
 730         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 731         return NDR_ERR_SUCCESS;
 732 }
 733
 734 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 735 {
 736         uint32_t v;
 737         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 738         *r = v;
 739         return NDR_ERR_SUCCESS;
 740 }
 741
 742 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 743 {
 744         ndr_print_uint32(ndr, name, r);
 745         ndr->depth++;
 746         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
 747         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
 748         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
 749         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
 750         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
 751         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
 752         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
 753         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
 754         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
 755         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
 756         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
 757         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
 758         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
 759         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
 760         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
 761         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
 762         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
 763         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
 764         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
 765         ndr->depth--;
 766 }
 767
 768 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
 769 {
 770         if (ndr_flags & NDR_SCALARS) {
 771                 NDR_CHECK(ndr_push_align(ndr, 4));
 772                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
 773                 {
 774                         uint32_t _flags_save_string = ndr->flags;
 775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 776                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
 777                         ndr->flags = _flags_save_string;
 778                 }
 779                 {
 780                         uint32_t _flags_save_string = ndr->flags;
 781                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 782                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
 783                         ndr->flags = _flags_save_string;
 784                 }
 785                 {
 786                         uint32_t _flags_save_string = ndr->flags;
 787                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 788                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 789                         ndr->flags = _flags_save_string;
 790                 }
 791         }
 792         if (ndr_flags & NDR_BUFFERS) {
 793                 {
 794                         uint32_t _flags_save_string = ndr->flags;
 795                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 796                         if (r->description) {
 797                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->description));
 798                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
 799                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->description));
 800                         }
 801                         ndr->flags = _flags_save_string;
 802                 }
 803                 {
 804                         uint32_t _flags_save_string = ndr->flags;
 805                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 806                         if (r->name) {
 807                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->name));
 808                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 809                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->name));
 810                         }
 811                         ndr->flags = _flags_save_string;
 812                 }
 813                 {
 814                         uint32_t _flags_save_string = ndr->flags;
 815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 816                         if (r->comment) {
 817                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->comment));
 818                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
 819                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->comment));
 820                         }
 821                         ndr->flags = _flags_save_string;
 822                 }
 823         }
 824         return NDR_ERR_SUCCESS;
 825 }
 826
 827 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
 828 {
 829         uint32_t _ptr_description;
 830         TALLOC_CTX *_mem_save_description_0;
 831         uint32_t _ptr_name;
 832         TALLOC_CTX *_mem_save_name_0;
 833         uint32_t _ptr_comment;
 834         TALLOC_CTX *_mem_save_comment_0;
 835         if (ndr_flags & NDR_SCALARS) {
 836                 NDR_CHECK(ndr_pull_align(ndr, 4));
 837                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
 838                 {
 839                         uint32_t _flags_save_string = ndr->flags;
 840                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 841                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
 842                         if (_ptr_description) {
 843                                 NDR_PULL_ALLOC(ndr, r->description);
 844                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
 845                         } else {
 846                                 r->description = NULL;
 847                         }
 848                         ndr->flags = _flags_save_string;
 849                 }
 850                 {
 851                         uint32_t _flags_save_string = ndr->flags;
 852                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 853                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 854                         if (_ptr_name) {
 855                                 NDR_PULL_ALLOC(ndr, r->name);
 856                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
 857                         } else {
 858                                 r->name = NULL;
 859                         }
 860                         ndr->flags = _flags_save_string;
 861                 }
 862                 {
 863                         uint32_t _flags_save_string = ndr->flags;
 864                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 865                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 866                         if (_ptr_comment) {
 867                                 NDR_PULL_ALLOC(ndr, r->comment);
 868                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
 869                         } else {
 870                                 r->comment = NULL;
 871                         }
 872                         ndr->flags = _flags_save_string;
 873                 }
 874         }
 875         if (ndr_flags & NDR_BUFFERS) {
 876                 {
 877                         uint32_t _flags_save_string = ndr->flags;
 878                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 879                         if (r->description) {
 880                                 uint32_t _relative_save_offset;
 881                                 _relative_save_offset = ndr->offset;
 882                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
 883                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
 884                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
 885                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
 886                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
 887                                 ndr->offset = _relative_save_offset;
 888                         }
 889                         ndr->flags = _flags_save_string;
 890                 }
 891                 {
 892                         uint32_t _flags_save_string = ndr->flags;
 893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 894                         if (r->name) {
 895                                 uint32_t _relative_save_offset;
 896                                 _relative_save_offset = ndr->offset;
 897                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
 898                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 899                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 900                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 901                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 902                                 ndr->offset = _relative_save_offset;
 903                         }
 904                         ndr->flags = _flags_save_string;
 905                 }
 906                 {
 907                         uint32_t _flags_save_string = ndr->flags;
 908                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 909                         if (r->comment) {
 910                                 uint32_t _relative_save_offset;
 911                                 _relative_save_offset = ndr->offset;
 912                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
 913                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 914                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 915                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
 916                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 917                                 ndr->offset = _relative_save_offset;
 918                         }
 919                         ndr->flags = _flags_save_string;
 920                 }
 921         }
 922         return NDR_ERR_SUCCESS;
 923 }
 924
 925 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
 926 {
 927         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
 928         ndr->depth++;
 929         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
 930         ndr_print_ptr(ndr, "description", r->description);
 931         ndr->depth++;
 932         if (r->description) {
 933                 ndr_print_string(ndr, "description", r->description);
 934         }
 935         ndr->depth--;
 936         ndr_print_ptr(ndr, "name", r->name);
 937         ndr->depth++;
 938         if (r->name) {
 939                 ndr_print_string(ndr, "name", r->name);
 940         }
 941         ndr->depth--;
 942         ndr_print_ptr(ndr, "comment", r->comment);
 943         ndr->depth++;
 944         if (r->comment) {
 945                 ndr_print_string(ndr, "comment", r->comment);
 946         }
 947         ndr->depth--;
 948         ndr->depth--;
 949 }
 950
 951 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo1(const struct spoolss_PrinterInfo1 *r, struct smb_iconv_convenience *ic, int flags)
 952 {
 953         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1, ic);
 954 }
 955
 956 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 957 {
 958         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 959         return NDR_ERR_SUCCESS;
 960 }
 961
 962 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 963 {
 964         uint32_t v;
 965         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 966         *r = v;
 967         return NDR_ERR_SUCCESS;
 968 }
 969
 970 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
 971 {
 972         ndr_print_uint32(ndr, name, r);
 973         ndr->depth++;
 974         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
 975         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
 976         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
 977         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
 978         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
 979         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
 980         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
 981         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
 982         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
 983         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
 984         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
 985         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
 986         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
 987         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
 988         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
 989         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
 990         ndr->depth--;
 991 }
 992
 993 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
 994 {
 995         if (ndr_flags & NDR_SCALARS) {
 996                 NDR_CHECK(ndr_push_align(ndr, 4));
 997                 {
 998                         uint32_t _flags_save_string = ndr->flags;
 999                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1000                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1001                         ndr->flags = _flags_save_string;
1002                 }
1003                 {
1004                         uint32_t _flags_save_string = ndr->flags;
1005                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1006                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1007                         ndr->flags = _flags_save_string;
1008                 }
1009                 {
1010                         uint32_t _flags_save_string = ndr->flags;
1011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1012                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
1013                         ndr->flags = _flags_save_string;
1014                 }
1015                 {
1016                         uint32_t _flags_save_string = ndr->flags;
1017                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1018                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1019                         ndr->flags = _flags_save_string;
1020                 }
1021                 {
1022                         uint32_t _flags_save_string = ndr->flags;
1023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1024                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1025                         ndr->flags = _flags_save_string;
1026                 }
1027                 {
1028                         uint32_t _flags_save_string = ndr->flags;
1029                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1030                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1031                         ndr->flags = _flags_save_string;
1032                 }
1033                 {
1034                         uint32_t _flags_save_string = ndr->flags;
1035                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1036                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1037                         ndr->flags = _flags_save_string;
1038                 }
1039                 {
1040                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
1041                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1042                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1043                         ndr->flags = _flags_save_spoolss_DeviceMode;
1044                 }
1045                 {
1046                         uint32_t _flags_save_string = ndr->flags;
1047                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1048                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1049                         ndr->flags = _flags_save_string;
1050                 }
1051                 {
1052                         uint32_t _flags_save_string = ndr->flags;
1053                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1054                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1055                         ndr->flags = _flags_save_string;
1056                 }
1057                 {
1058                         uint32_t _flags_save_string = ndr->flags;
1059                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1060                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1061                         ndr->flags = _flags_save_string;
1062                 }
1063                 {
1064                         uint32_t _flags_save_string = ndr->flags;
1065                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1066                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1067                         ndr->flags = _flags_save_string;
1068                 }
1069                 {
1070                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1072                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1073                         ndr->flags = _flags_save_spoolss_security_descriptor;
1074                 }
1075                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1080                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1082                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1083         }
1084         if (ndr_flags & NDR_BUFFERS) {
1085                 {
1086                         uint32_t _flags_save_string = ndr->flags;
1087                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1088                         if (r->servername) {
1089                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->servername));
1090                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1091                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->servername));
1092                         }
1093                         ndr->flags = _flags_save_string;
1094                 }
1095                 {
1096                         uint32_t _flags_save_string = ndr->flags;
1097                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1098                         if (r->printername) {
1099                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
1100                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1101                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
1102                         }
1103                         ndr->flags = _flags_save_string;
1104                 }
1105                 {
1106                         uint32_t _flags_save_string = ndr->flags;
1107                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1108                         if (r->sharename) {
1109                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->sharename));
1110                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1111                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->sharename));
1112                         }
1113                         ndr->flags = _flags_save_string;
1114                 }
1115                 {
1116                         uint32_t _flags_save_string = ndr->flags;
1117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1118                         if (r->portname) {
1119                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->portname));
1120                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1121                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->portname));
1122                         }
1123                         ndr->flags = _flags_save_string;
1124                 }
1125                 {
1126                         uint32_t _flags_save_string = ndr->flags;
1127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1128                         if (r->drivername) {
1129                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->drivername));
1130                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1131                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->drivername));
1132                         }
1133                         ndr->flags = _flags_save_string;
1134                 }
1135                 {
1136                         uint32_t _flags_save_string = ndr->flags;
1137                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1138                         if (r->comment) {
1139                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->comment));
1140                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1141                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->comment));
1142                         }
1143                         ndr->flags = _flags_save_string;
1144                 }
1145                 {
1146                         uint32_t _flags_save_string = ndr->flags;
1147                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1148                         if (r->location) {
1149                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->location));
1150                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1151                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->location));
1152                         }
1153                         ndr->flags = _flags_save_string;
1154                 }
1155                 {
1156                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
1157                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1158                         if (r->devmode) {
1159                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
1160                                 {
1161                                         struct ndr_push *_ndr_devmode;
1162                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1163                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1164                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1165                                 }
1166                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
1167                         }
1168                         ndr->flags = _flags_save_spoolss_DeviceMode;
1169                 }
1170                 {
1171                         uint32_t _flags_save_string = ndr->flags;
1172                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1173                         if (r->sepfile) {
1174                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->sepfile));
1175                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1176                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->sepfile));
1177                         }
1178                         ndr->flags = _flags_save_string;
1179                 }
1180                 {
1181                         uint32_t _flags_save_string = ndr->flags;
1182                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1183                         if (r->printprocessor) {
1184                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printprocessor));
1185                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1186                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printprocessor));
1187                         }
1188                         ndr->flags = _flags_save_string;
1189                 }
1190                 {
1191                         uint32_t _flags_save_string = ndr->flags;
1192                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1193                         if (r->datatype) {
1194                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->datatype));
1195                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1196                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->datatype));
1197                         }
1198                         ndr->flags = _flags_save_string;
1199                 }
1200                 {
1201                         uint32_t _flags_save_string = ndr->flags;
1202                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1203                         if (r->parameters) {
1204                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->parameters));
1205                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1206                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->parameters));
1207                         }
1208                         ndr->flags = _flags_save_string;
1209                 }
1210                 {
1211                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1212                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1213                         if (r->secdesc) {
1214                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
1215                                 {
1216                                         struct ndr_push *_ndr_secdesc;
1217                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1218                                         NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1219                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1220                                 }
1221                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
1222                         }
1223                         ndr->flags = _flags_save_spoolss_security_descriptor;
1224                 }
1225         }
1226         return NDR_ERR_SUCCESS;
1227 }
1228
1229 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1230 {
1231         uint32_t _ptr_servername;
1232         TALLOC_CTX *_mem_save_servername_0;
1233         uint32_t _ptr_printername;
1234         TALLOC_CTX *_mem_save_printername_0;
1235         uint32_t _ptr_sharename;
1236         TALLOC_CTX *_mem_save_sharename_0;
1237         uint32_t _ptr_portname;
1238         TALLOC_CTX *_mem_save_portname_0;
1239         uint32_t _ptr_drivername;
1240         TALLOC_CTX *_mem_save_drivername_0;
1241         uint32_t _ptr_comment;
1242         TALLOC_CTX *_mem_save_comment_0;
1243         uint32_t _ptr_location;
1244         TALLOC_CTX *_mem_save_location_0;
1245         uint32_t _ptr_devmode;
1246         TALLOC_CTX *_mem_save_devmode_0;
1247         uint32_t _ptr_sepfile;
1248         TALLOC_CTX *_mem_save_sepfile_0;
1249         uint32_t _ptr_printprocessor;
1250         TALLOC_CTX *_mem_save_printprocessor_0;
1251         uint32_t _ptr_datatype;
1252         TALLOC_CTX *_mem_save_datatype_0;
1253         uint32_t _ptr_parameters;
1254         TALLOC_CTX *_mem_save_parameters_0;
1255         uint32_t _ptr_secdesc;
1256         TALLOC_CTX *_mem_save_secdesc_0;
1257         if (ndr_flags & NDR_SCALARS) {
1258                 NDR_CHECK(ndr_pull_align(ndr, 4));
1259                 {
1260                         uint32_t _flags_save_string = ndr->flags;
1261                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1262                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1263                         if (_ptr_servername) {
1264                                 NDR_PULL_ALLOC(ndr, r->servername);
1265                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1266                         } else {
1267                                 r->servername = NULL;
1268                         }
1269                         ndr->flags = _flags_save_string;
1270                 }
1271                 {
1272                         uint32_t _flags_save_string = ndr->flags;
1273                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1274                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1275                         if (_ptr_printername) {
1276                                 NDR_PULL_ALLOC(ndr, r->printername);
1277                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1278                         } else {
1279                                 r->printername = NULL;
1280                         }
1281                         ndr->flags = _flags_save_string;
1282                 }
1283                 {
1284                         uint32_t _flags_save_string = ndr->flags;
1285                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1286                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1287                         if (_ptr_sharename) {
1288                                 NDR_PULL_ALLOC(ndr, r->sharename);
1289                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1290                         } else {
1291                                 r->sharename = NULL;
1292                         }
1293                         ndr->flags = _flags_save_string;
1294                 }
1295                 {
1296                         uint32_t _flags_save_string = ndr->flags;
1297                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1298                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1299                         if (_ptr_portname) {
1300                                 NDR_PULL_ALLOC(ndr, r->portname);
1301                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1302                         } else {
1303                                 r->portname = NULL;
1304                         }
1305                         ndr->flags = _flags_save_string;
1306                 }
1307                 {
1308                         uint32_t _flags_save_string = ndr->flags;
1309                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1310                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1311                         if (_ptr_drivername) {
1312                                 NDR_PULL_ALLOC(ndr, r->drivername);
1313                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1314                         } else {
1315                                 r->drivername = NULL;
1316                         }
1317                         ndr->flags = _flags_save_string;
1318                 }
1319                 {
1320                         uint32_t _flags_save_string = ndr->flags;
1321                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1322                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1323                         if (_ptr_comment) {
1324                                 NDR_PULL_ALLOC(ndr, r->comment);
1325                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1326                         } else {
1327                                 r->comment = NULL;
1328                         }
1329                         ndr->flags = _flags_save_string;
1330                 }
1331                 {
1332                         uint32_t _flags_save_string = ndr->flags;
1333                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1334                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1335                         if (_ptr_location) {
1336                                 NDR_PULL_ALLOC(ndr, r->location);
1337                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1338                         } else {
1339                                 r->location = NULL;
1340                         }
1341                         ndr->flags = _flags_save_string;
1342                 }
1343                 {
1344                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
1345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1346                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1347                         if (_ptr_devmode) {
1348                                 NDR_PULL_ALLOC(ndr, r->devmode);
1349                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1350                         } else {
1351                                 r->devmode = NULL;
1352                         }
1353                         ndr->flags = _flags_save_spoolss_DeviceMode;
1354                 }
1355                 {
1356                         uint32_t _flags_save_string = ndr->flags;
1357                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1358                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1359                         if (_ptr_sepfile) {
1360                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1361                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1362                         } else {
1363                                 r->sepfile = NULL;
1364                         }
1365                         ndr->flags = _flags_save_string;
1366                 }
1367                 {
1368                         uint32_t _flags_save_string = ndr->flags;
1369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1370                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1371                         if (_ptr_printprocessor) {
1372                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1373                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1374                         } else {
1375                                 r->printprocessor = NULL;
1376                         }
1377                         ndr->flags = _flags_save_string;
1378                 }
1379                 {
1380                         uint32_t _flags_save_string = ndr->flags;
1381                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1382                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1383                         if (_ptr_datatype) {
1384                                 NDR_PULL_ALLOC(ndr, r->datatype);
1385                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1386                         } else {
1387                                 r->datatype = NULL;
1388                         }
1389                         ndr->flags = _flags_save_string;
1390                 }
1391                 {
1392                         uint32_t _flags_save_string = ndr->flags;
1393                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1394                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1395                         if (_ptr_parameters) {
1396                                 NDR_PULL_ALLOC(ndr, r->parameters);
1397                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1398                         } else {
1399                                 r->parameters = NULL;
1400                         }
1401                         ndr->flags = _flags_save_string;
1402                 }
1403                 {
1404                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1405                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1406                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1407                         if (_ptr_secdesc) {
1408                                 NDR_PULL_ALLOC(ndr, r->secdesc);
1409                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1410                         } else {
1411                                 r->secdesc = NULL;
1412                         }
1413                         ndr->flags = _flags_save_spoolss_security_descriptor;
1414                 }
1415                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1417                 if (r->priority > 99) {
1418                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1419                 }
1420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1423                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1424                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1426         }
1427         if (ndr_flags & NDR_BUFFERS) {
1428                 {
1429                         uint32_t _flags_save_string = ndr->flags;
1430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1431                         if (r->servername) {
1432                                 uint32_t _relative_save_offset;
1433                                 _relative_save_offset = ndr->offset;
1434                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1435                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1436                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1437                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1438                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1439                                 ndr->offset = _relative_save_offset;
1440                         }
1441                         ndr->flags = _flags_save_string;
1442                 }
1443                 {
1444                         uint32_t _flags_save_string = ndr->flags;
1445                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1446                         if (r->printername) {
1447                                 uint32_t _relative_save_offset;
1448                                 _relative_save_offset = ndr->offset;
1449                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1450                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1451                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1452                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1453                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1454                                 ndr->offset = _relative_save_offset;
1455                         }
1456                         ndr->flags = _flags_save_string;
1457                 }
1458                 {
1459                         uint32_t _flags_save_string = ndr->flags;
1460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1461                         if (r->sharename) {
1462                                 uint32_t _relative_save_offset;
1463                                 _relative_save_offset = ndr->offset;
1464                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1465                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1466                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1467                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1468                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1469                                 ndr->offset = _relative_save_offset;
1470                         }
1471                         ndr->flags = _flags_save_string;
1472                 }
1473                 {
1474                         uint32_t _flags_save_string = ndr->flags;
1475                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1476                         if (r->portname) {
1477                                 uint32_t _relative_save_offset;
1478                                 _relative_save_offset = ndr->offset;
1479                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1480                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1481                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1482                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1483                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1484                                 ndr->offset = _relative_save_offset;
1485                         }
1486                         ndr->flags = _flags_save_string;
1487                 }
1488                 {
1489                         uint32_t _flags_save_string = ndr->flags;
1490                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1491                         if (r->drivername) {
1492                                 uint32_t _relative_save_offset;
1493                                 _relative_save_offset = ndr->offset;
1494                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1495                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1496                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1497                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1498                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1499                                 ndr->offset = _relative_save_offset;
1500                         }
1501                         ndr->flags = _flags_save_string;
1502                 }
1503                 {
1504                         uint32_t _flags_save_string = ndr->flags;
1505                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1506                         if (r->comment) {
1507                                 uint32_t _relative_save_offset;
1508                                 _relative_save_offset = ndr->offset;
1509                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1510                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1511                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1512                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1513                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1514                                 ndr->offset = _relative_save_offset;
1515                         }
1516                         ndr->flags = _flags_save_string;
1517                 }
1518                 {
1519                         uint32_t _flags_save_string = ndr->flags;
1520                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1521                         if (r->location) {
1522                                 uint32_t _relative_save_offset;
1523                                 _relative_save_offset = ndr->offset;
1524                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1525                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1526                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1527                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1528                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1529                                 ndr->offset = _relative_save_offset;
1530                         }
1531                         ndr->flags = _flags_save_string;
1532                 }
1533                 {
1534                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
1535                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1536                         if (r->devmode) {
1537                                 uint32_t _relative_save_offset;
1538                                 _relative_save_offset = ndr->offset;
1539                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1540                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1541                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1542                                 {
1543                                         struct ndr_pull *_ndr_devmode;
1544                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1545                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1546                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1547                                 }
1548                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1549                                 ndr->offset = _relative_save_offset;
1550                         }
1551                         ndr->flags = _flags_save_spoolss_DeviceMode;
1552                 }
1553                 {
1554                         uint32_t _flags_save_string = ndr->flags;
1555                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1556                         if (r->sepfile) {
1557                                 uint32_t _relative_save_offset;
1558                                 _relative_save_offset = ndr->offset;
1559                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1560                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1561                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1562                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1563                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1564                                 ndr->offset = _relative_save_offset;
1565                         }
1566                         ndr->flags = _flags_save_string;
1567                 }
1568                 {
1569                         uint32_t _flags_save_string = ndr->flags;
1570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1571                         if (r->printprocessor) {
1572                                 uint32_t _relative_save_offset;
1573                                 _relative_save_offset = ndr->offset;
1574                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1575                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1576                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1577                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1578                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1579                                 ndr->offset = _relative_save_offset;
1580                         }
1581                         ndr->flags = _flags_save_string;
1582                 }
1583                 {
1584                         uint32_t _flags_save_string = ndr->flags;
1585                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1586                         if (r->datatype) {
1587                                 uint32_t _relative_save_offset;
1588                                 _relative_save_offset = ndr->offset;
1589                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
1590                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1591                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
1592                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
1593                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
1594                                 ndr->offset = _relative_save_offset;
1595                         }
1596                         ndr->flags = _flags_save_string;
1597                 }
1598                 {
1599                         uint32_t _flags_save_string = ndr->flags;
1600                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1601                         if (r->parameters) {
1602                                 uint32_t _relative_save_offset;
1603                                 _relative_save_offset = ndr->offset;
1604                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
1605                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
1606                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
1607                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
1608                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
1609                                 ndr->offset = _relative_save_offset;
1610                         }
1611                         ndr->flags = _flags_save_string;
1612                 }
1613                 {
1614                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1616                         if (r->secdesc) {
1617                                 uint32_t _relative_save_offset;
1618                                 _relative_save_offset = ndr->offset;
1619                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1620                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1621                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1622                                 {
1623                                         struct ndr_pull *_ndr_secdesc;
1624                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1625                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1626                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1627                                 }
1628                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1629                                 ndr->offset = _relative_save_offset;
1630                         }
1631                         ndr->flags = _flags_save_spoolss_security_descriptor;
1632                 }
1633         }
1634         return NDR_ERR_SUCCESS;
1635 }
1636
1637 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
1638 {
1639         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
1640         ndr->depth++;
1641         ndr_print_ptr(ndr, "servername", r->servername);
1642         ndr->depth++;
1643         if (r->servername) {
1644                 ndr_print_string(ndr, "servername", r->servername);
1645         }
1646         ndr->depth--;
1647         ndr_print_ptr(ndr, "printername", r->printername);
1648         ndr->depth++;
1649         if (r->printername) {
1650                 ndr_print_string(ndr, "printername", r->printername);
1651         }
1652         ndr->depth--;
1653         ndr_print_ptr(ndr, "sharename", r->sharename);
1654         ndr->depth++;
1655         if (r->sharename) {
1656                 ndr_print_string(ndr, "sharename", r->sharename);
1657         }
1658         ndr->depth--;
1659         ndr_print_ptr(ndr, "portname", r->portname);
1660         ndr->depth++;
1661         if (r->portname) {
1662                 ndr_print_string(ndr, "portname", r->portname);
1663         }
1664         ndr->depth--;
1665         ndr_print_ptr(ndr, "drivername", r->drivername);
1666         ndr->depth++;
1667         if (r->drivername) {
1668                 ndr_print_string(ndr, "drivername", r->drivername);
1669         }
1670         ndr->depth--;
1671         ndr_print_ptr(ndr, "comment", r->comment);
1672         ndr->depth++;
1673         if (r->comment) {
1674                 ndr_print_string(ndr, "comment", r->comment);
1675         }
1676         ndr->depth--;
1677         ndr_print_ptr(ndr, "location", r->location);
1678         ndr->depth++;
1679         if (r->location) {
1680                 ndr_print_string(ndr, "location", r->location);
1681         }
1682         ndr->depth--;
1683         ndr_print_ptr(ndr, "devmode", r->devmode);
1684         ndr->depth++;
1685         if (r->devmode) {
1686                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1687         }
1688         ndr->depth--;
1689         ndr_print_ptr(ndr, "sepfile", r->sepfile);
1690         ndr->depth++;
1691         if (r->sepfile) {
1692                 ndr_print_string(ndr, "sepfile", r->sepfile);
1693         }
1694         ndr->depth--;
1695         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
1696         ndr->depth++;
1697         if (r->printprocessor) {
1698                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
1699         }
1700         ndr->depth--;
1701         ndr_print_ptr(ndr, "datatype", r->datatype);
1702         ndr->depth++;
1703         if (r->datatype) {
1704                 ndr_print_string(ndr, "datatype", r->datatype);
1705         }
1706         ndr->depth--;
1707         ndr_print_ptr(ndr, "parameters", r->parameters);
1708         ndr->depth++;
1709         if (r->parameters) {
1710                 ndr_print_string(ndr, "parameters", r->parameters);
1711         }
1712         ndr->depth--;
1713         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1714         ndr->depth++;
1715         if (r->secdesc) {
1716                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
1717         }
1718         ndr->depth--;
1719         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1720         ndr_print_uint32(ndr, "priority", r->priority);
1721         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
1722         ndr_print_uint32(ndr, "starttime", r->starttime);
1723         ndr_print_uint32(ndr, "untiltime", r->untiltime);
1724         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1725         ndr_print_uint32(ndr, "cjobs", r->cjobs);
1726         ndr_print_uint32(ndr, "averageppm", r->averageppm);
1727         ndr->depth--;
1728 }
1729
1730 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo2(const struct spoolss_PrinterInfo2 *r, struct smb_iconv_convenience *ic, int flags)
1731 {
1732         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2, ic);
1733 }
1734
1735 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
1736 {
1737         if (ndr_flags & NDR_SCALARS) {
1738                 NDR_CHECK(ndr_push_align(ndr, 4));
1739                 {
1740                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1741                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1742                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1743                         ndr->flags = _flags_save_spoolss_security_descriptor;
1744                 }
1745         }
1746         if (ndr_flags & NDR_BUFFERS) {
1747                 {
1748                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1749                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1750                         if (r->secdesc) {
1751                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
1752                                 {
1753                                         struct ndr_push *_ndr_secdesc;
1754                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1755                                         NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1756                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1757                                 }
1758                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
1759                         }
1760                         ndr->flags = _flags_save_spoolss_security_descriptor;
1761                 }
1762         }
1763         return NDR_ERR_SUCCESS;
1764 }
1765
1766 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
1767 {
1768         uint32_t _ptr_secdesc;
1769         TALLOC_CTX *_mem_save_secdesc_0;
1770         if (ndr_flags & NDR_SCALARS) {
1771                 NDR_CHECK(ndr_pull_align(ndr, 4));
1772                 {
1773                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1775                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1776                         if (_ptr_secdesc) {
1777                                 NDR_PULL_ALLOC(ndr, r->secdesc);
1778                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1779                         } else {
1780                                 r->secdesc = NULL;
1781                         }
1782                         ndr->flags = _flags_save_spoolss_security_descriptor;
1783                 }
1784         }
1785         if (ndr_flags & NDR_BUFFERS) {
1786                 {
1787                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1789                         if (r->secdesc) {
1790                                 uint32_t _relative_save_offset;
1791                                 _relative_save_offset = ndr->offset;
1792                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1793                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1794                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1795                                 {
1796                                         struct ndr_pull *_ndr_secdesc;
1797                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1798                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1799                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1800                                 }
1801                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1802                                 ndr->offset = _relative_save_offset;
1803                         }
1804                         ndr->flags = _flags_save_spoolss_security_descriptor;
1805                 }
1806         }
1807         return NDR_ERR_SUCCESS;
1808 }
1809
1810 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
1811 {
1812         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
1813         ndr->depth++;
1814         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1815         ndr->depth++;
1816         if (r->secdesc) {
1817                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
1818         }
1819         ndr->depth--;
1820         ndr->depth--;
1821 }
1822
1823 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo3(const struct spoolss_PrinterInfo3 *r, struct smb_iconv_convenience *ic, int flags)
1824 {
1825         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo3, ic);
1826 }
1827
1828 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
1829 {
1830         if (ndr_flags & NDR_SCALARS) {
1831                 NDR_CHECK(ndr_push_align(ndr, 4));
1832                 {
1833                         uint32_t _flags_save_string = ndr->flags;
1834                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1835                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1836                         ndr->flags = _flags_save_string;
1837                 }
1838                 {
1839                         uint32_t _flags_save_string = ndr->flags;
1840                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1841                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1842                         ndr->flags = _flags_save_string;
1843                 }
1844                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1845         }
1846         if (ndr_flags & NDR_BUFFERS) {
1847                 {
1848                         uint32_t _flags_save_string = ndr->flags;
1849                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1850                         if (r->printername) {
1851                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
1852                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1853                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
1854                         }
1855                         ndr->flags = _flags_save_string;
1856                 }
1857                 {
1858                         uint32_t _flags_save_string = ndr->flags;
1859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1860                         if (r->servername) {
1861                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->servername));
1862                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1863                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->servername));
1864                         }
1865                         ndr->flags = _flags_save_string;
1866                 }
1867         }
1868         return NDR_ERR_SUCCESS;
1869 }
1870
1871 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
1872 {
1873         uint32_t _ptr_printername;
1874         TALLOC_CTX *_mem_save_printername_0;
1875         uint32_t _ptr_servername;
1876         TALLOC_CTX *_mem_save_servername_0;
1877         if (ndr_flags & NDR_SCALARS) {
1878                 NDR_CHECK(ndr_pull_align(ndr, 4));
1879                 {
1880                         uint32_t _flags_save_string = ndr->flags;
1881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1882                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1883                         if (_ptr_printername) {
1884                                 NDR_PULL_ALLOC(ndr, r->printername);
1885                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1886                         } else {
1887                                 r->printername = NULL;
1888                         }
1889                         ndr->flags = _flags_save_string;
1890                 }
1891                 {
1892                         uint32_t _flags_save_string = ndr->flags;
1893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1894                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1895                         if (_ptr_servername) {
1896                                 NDR_PULL_ALLOC(ndr, r->servername);
1897                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1898                         } else {
1899                                 r->servername = NULL;
1900                         }
1901                         ndr->flags = _flags_save_string;
1902                 }
1903                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1904         }
1905         if (ndr_flags & NDR_BUFFERS) {
1906                 {
1907                         uint32_t _flags_save_string = ndr->flags;
1908                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1909                         if (r->printername) {
1910                                 uint32_t _relative_save_offset;
1911                                 _relative_save_offset = ndr->offset;
1912                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1913                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1914                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1915                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1916                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1917                                 ndr->offset = _relative_save_offset;
1918                         }
1919                         ndr->flags = _flags_save_string;
1920                 }
1921                 {
1922                         uint32_t _flags_save_string = ndr->flags;
1923                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1924                         if (r->servername) {
1925                                 uint32_t _relative_save_offset;
1926                                 _relative_save_offset = ndr->offset;
1927                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1928                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1929                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1930                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1931                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1932                                 ndr->offset = _relative_save_offset;
1933                         }
1934                         ndr->flags = _flags_save_string;
1935                 }
1936         }
1937         return NDR_ERR_SUCCESS;
1938 }
1939
1940 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
1941 {
1942         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
1943         ndr->depth++;
1944         ndr_print_ptr(ndr, "printername", r->printername);
1945         ndr->depth++;
1946         if (r->printername) {
1947                 ndr_print_string(ndr, "printername", r->printername);
1948         }
1949         ndr->depth--;
1950         ndr_print_ptr(ndr, "servername", r->servername);
1951         ndr->depth++;
1952         if (r->servername) {
1953                 ndr_print_string(ndr, "servername", r->servername);
1954         }
1955         ndr->depth--;
1956         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1957         ndr->depth--;
1958 }
1959
1960 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo4(const struct spoolss_PrinterInfo4 *r, struct smb_iconv_convenience *ic, int flags)
1961 {
1962         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo4, ic);
1963 }
1964
1965 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
1966 {
1967         if (ndr_flags & NDR_SCALARS) {
1968                 NDR_CHECK(ndr_push_align(ndr, 4));
1969                 {
1970                         uint32_t _flags_save_string = ndr->flags;
1971                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1972                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1973                         ndr->flags = _flags_save_string;
1974                 }
1975                 {
1976                         uint32_t _flags_save_string = ndr->flags;
1977                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1978                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1979                         ndr->flags = _flags_save_string;
1980                 }
1981                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
1983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
1984         }
1985         if (ndr_flags & NDR_BUFFERS) {
1986                 {
1987                         uint32_t _flags_save_string = ndr->flags;
1988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1989                         if (r->printername) {
1990                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
1991                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1992                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
1993                         }
1994                         ndr->flags = _flags_save_string;
1995                 }
1996                 {
1997                         uint32_t _flags_save_string = ndr->flags;
1998                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1999                         if (r->portname) {
2000                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->portname));
2001                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
2002                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->portname));
2003                         }
2004                         ndr->flags = _flags_save_string;
2005                 }
2006         }
2007         return NDR_ERR_SUCCESS;
2008 }
2009
2010 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
2011 {
2012         uint32_t _ptr_printername;
2013         TALLOC_CTX *_mem_save_printername_0;
2014         uint32_t _ptr_portname;
2015         TALLOC_CTX *_mem_save_portname_0;
2016         if (ndr_flags & NDR_SCALARS) {
2017                 NDR_CHECK(ndr_pull_align(ndr, 4));
2018                 {
2019                         uint32_t _flags_save_string = ndr->flags;
2020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2021                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2022                         if (_ptr_printername) {
2023                                 NDR_PULL_ALLOC(ndr, r->printername);
2024                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2025                         } else {
2026                                 r->printername = NULL;
2027                         }
2028                         ndr->flags = _flags_save_string;
2029                 }
2030                 {
2031                         uint32_t _flags_save_string = ndr->flags;
2032                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2033                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
2034                         if (_ptr_portname) {
2035                                 NDR_PULL_ALLOC(ndr, r->portname);
2036                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
2037                         } else {
2038                                 r->portname = NULL;
2039                         }
2040                         ndr->flags = _flags_save_string;
2041                 }
2042                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2043                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
2044                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
2045         }
2046         if (ndr_flags & NDR_BUFFERS) {
2047                 {
2048                         uint32_t _flags_save_string = ndr->flags;
2049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2050                         if (r->printername) {
2051                                 uint32_t _relative_save_offset;
2052                                 _relative_save_offset = ndr->offset;
2053                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2054                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2055                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2056                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2057                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2058                                 ndr->offset = _relative_save_offset;
2059                         }
2060                         ndr->flags = _flags_save_string;
2061                 }
2062                 {
2063                         uint32_t _flags_save_string = ndr->flags;
2064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2065                         if (r->portname) {
2066                                 uint32_t _relative_save_offset;
2067                                 _relative_save_offset = ndr->offset;
2068                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
2069                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2070                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
2071                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
2072                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
2073                                 ndr->offset = _relative_save_offset;
2074                         }
2075                         ndr->flags = _flags_save_string;
2076                 }
2077         }
2078         return NDR_ERR_SUCCESS;
2079 }
2080
2081 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
2082 {
2083         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
2084         ndr->depth++;
2085         ndr_print_ptr(ndr, "printername", r->printername);
2086         ndr->depth++;
2087         if (r->printername) {
2088                 ndr_print_string(ndr, "printername", r->printername);
2089         }
2090         ndr->depth--;
2091         ndr_print_ptr(ndr, "portname", r->portname);
2092         ndr->depth++;
2093         if (r->portname) {
2094                 ndr_print_string(ndr, "portname", r->portname);
2095         }
2096         ndr->depth--;
2097         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2098         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
2099         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
2100         ndr->depth--;
2101 }
2102
2103 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo5(const struct spoolss_PrinterInfo5 *r, struct smb_iconv_convenience *ic, int flags)
2104 {
2105         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5, ic);
2106 }
2107
2108 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
2109 {
2110         if (ndr_flags & NDR_SCALARS) {
2111                 NDR_CHECK(ndr_push_align(ndr, 4));
2112                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
2113         }
2114         if (ndr_flags & NDR_BUFFERS) {
2115         }
2116         return NDR_ERR_SUCCESS;
2117 }
2118
2119 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2120 {
2121         if (ndr_flags & NDR_SCALARS) {
2122                 NDR_CHECK(ndr_pull_align(ndr, 4));
2123                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2124         }
2125         if (ndr_flags & NDR_BUFFERS) {
2126         }
2127         return NDR_ERR_SUCCESS;
2128 }
2129
2130 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2131 {
2132         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2133         ndr->depth++;
2134         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2135         ndr->depth--;
2136 }
2137
2138 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo6(const struct spoolss_PrinterInfo6 *r, struct smb_iconv_convenience *ic, int flags)
2139 {
2140         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo6, ic);
2141 }
2142
2143 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2144 {
2145         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2146         return NDR_ERR_SUCCESS;
2147 }
2148
2149 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2150 {
2151         uint32_t v;
2152         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2153         *r = v;
2154         return NDR_ERR_SUCCESS;
2155 }
2156
2157 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2158 {
2159         ndr_print_uint32(ndr, name, r);
2160         ndr->depth++;
2161         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2162         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2163         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2164         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2165         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2166         ndr->depth--;
2167 }
2168
2169 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2170 {
2171         if (ndr_flags & NDR_SCALARS) {
2172                 NDR_CHECK(ndr_push_align(ndr, 4));
2173                 {
2174                         uint32_t _flags_save_string = ndr->flags;
2175                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2176                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2177                         ndr->flags = _flags_save_string;
2178                 }
2179                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2180         }
2181         if (ndr_flags & NDR_BUFFERS) {
2182                 {
2183                         uint32_t _flags_save_string = ndr->flags;
2184                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2185                         if (r->guid) {
2186                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->guid));
2187                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2188                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->guid));
2189                         }
2190                         ndr->flags = _flags_save_string;
2191                 }
2192         }
2193         return NDR_ERR_SUCCESS;
2194 }
2195
2196 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2197 {
2198         uint32_t _ptr_guid;
2199         TALLOC_CTX *_mem_save_guid_0;
2200         if (ndr_flags & NDR_SCALARS) {
2201                 NDR_CHECK(ndr_pull_align(ndr, 4));
2202                 {
2203                         uint32_t _flags_save_string = ndr->flags;
2204                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2205                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2206                         if (_ptr_guid) {
2207                                 NDR_PULL_ALLOC(ndr, r->guid);
2208                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2209                         } else {
2210                                 r->guid = NULL;
2211                         }
2212                         ndr->flags = _flags_save_string;
2213                 }
2214                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2215         }
2216         if (ndr_flags & NDR_BUFFERS) {
2217                 {
2218                         uint32_t _flags_save_string = ndr->flags;
2219                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2220                         if (r->guid) {
2221                                 uint32_t _relative_save_offset;
2222                                 _relative_save_offset = ndr->offset;
2223                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2224                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2225                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2226                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2227                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2228                                 ndr->offset = _relative_save_offset;
2229                         }
2230                         ndr->flags = _flags_save_string;
2231                 }
2232         }
2233         return NDR_ERR_SUCCESS;
2234 }
2235
2236 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2237 {
2238         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2239         ndr->depth++;
2240         ndr_print_ptr(ndr, "guid", r->guid);
2241         ndr->depth++;
2242         if (r->guid) {
2243                 ndr_print_string(ndr, "guid", r->guid);
2244         }
2245         ndr->depth--;
2246         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2247         ndr->depth--;
2248 }
2249
2250 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo7(const struct spoolss_PrinterInfo7 *r, struct smb_iconv_convenience *ic, int flags)
2251 {
2252         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo7, ic);
2253 }
2254
2255 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2256 {
2257         if (ndr_flags & NDR_SCALARS) {
2258                 NDR_CHECK(ndr_push_align(ndr, 4));
2259                 {
2260                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2261                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2262                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2263                         ndr->flags = _flags_save_spoolss_DeviceMode;
2264                 }
2265         }
2266         if (ndr_flags & NDR_BUFFERS) {
2267                 {
2268                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2270                         if (r->devmode) {
2271                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
2272                                 {
2273                                         struct ndr_push *_ndr_devmode;
2274                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2275                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2276                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2277                                 }
2278                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
2279                         }
2280                         ndr->flags = _flags_save_spoolss_DeviceMode;
2281                 }
2282         }
2283         return NDR_ERR_SUCCESS;
2284 }
2285
2286 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2287 {
2288         uint32_t _ptr_devmode;
2289         TALLOC_CTX *_mem_save_devmode_0;
2290         if (ndr_flags & NDR_SCALARS) {
2291                 NDR_CHECK(ndr_pull_align(ndr, 4));
2292                 {
2293                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2295                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2296                         if (_ptr_devmode) {
2297                                 NDR_PULL_ALLOC(ndr, r->devmode);
2298                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2299                         } else {
2300                                 r->devmode = NULL;
2301                         }
2302                         ndr->flags = _flags_save_spoolss_DeviceMode;
2303                 }
2304         }
2305         if (ndr_flags & NDR_BUFFERS) {
2306                 {
2307                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2309                         if (r->devmode) {
2310                                 uint32_t _relative_save_offset;
2311                                 _relative_save_offset = ndr->offset;
2312                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2313                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2314                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2315                                 {
2316                                         struct ndr_pull *_ndr_devmode;
2317                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2318                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2319                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2320                                 }
2321                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2322                                 ndr->offset = _relative_save_offset;
2323                         }
2324                         ndr->flags = _flags_save_spoolss_DeviceMode;
2325                 }
2326         }
2327         return NDR_ERR_SUCCESS;
2328 }
2329
2330 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2331 {
2332         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2333         ndr->depth++;
2334         ndr_print_ptr(ndr, "devmode", r->devmode);
2335         ndr->depth++;
2336         if (r->devmode) {
2337                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2338         }
2339         ndr->depth--;
2340         ndr->depth--;
2341 }
2342
2343 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2344 {
2345         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2346         {
2347                 uint32_t _flags_save_UNION = ndr->flags;
2348                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
2349                 if (ndr_flags & NDR_SCALARS) {
2350                         int level = ndr_push_get_switch_value(ndr, r);
2351                         switch (level) {
2352                                 case 0: {
2353                                         NDR_CHECK(ndr_push_align(ndr, 4));
2354                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2355                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2356                                 break; }
2357
2358                                 case 1: {
2359                                         NDR_CHECK(ndr_push_align(ndr, 4));
2360                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2361                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2362                                 break; }
2363
2364                                 case 2: {
2365                                         NDR_CHECK(ndr_push_align(ndr, 4));
2366                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2367                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2368                                 break; }
2369
2370                                 case 3: {
2371                                         NDR_CHECK(ndr_push_align(ndr, 4));
2372                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2373                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2374                                 break; }
2375
2376                                 case 4: {
2377                                         NDR_CHECK(ndr_push_align(ndr, 4));
2378                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2379                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2380                                 break; }
2381
2382                                 case 5: {
2383                                         NDR_CHECK(ndr_push_align(ndr, 4));
2384                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2385                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2386                                 break; }
2387
2388                                 case 6: {
2389                                         NDR_CHECK(ndr_push_align(ndr, 4));
2390                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2391                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2392                                 break; }
2393
2394                                 case 7: {
2395                                         NDR_CHECK(ndr_push_align(ndr, 4));
2396                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2397                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2398                                 break; }
2399
2400                                 case 8: {
2401                                         NDR_CHECK(ndr_push_align(ndr, 4));
2402                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2403                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2404                                 break; }
2405
2406                                 case 9: {
2407                                         NDR_CHECK(ndr_push_align(ndr, 4));
2408                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2409                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2410                                 break; }
2411
2412                                 default: {
2413                                 break; }
2414
2415                         }
2416                 }
2417                 if (ndr_flags & NDR_BUFFERS) {
2418                         int level = ndr_push_get_switch_value(ndr, r);
2419                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2420                         switch (level) {
2421                                 case 0:
2422                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2423                                 break;
2424
2425                                 case 1:
2426                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2427                                 break;
2428
2429                                 case 2:
2430                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2431                                 break;
2432
2433                                 case 3:
2434                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2435                                 break;
2436
2437                                 case 4:
2438                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2439                                 break;
2440
2441                                 case 5:
2442                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2443                                 break;
2444
2445                                 case 6:
2446                                 break;
2447
2448                                 case 7:
2449                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2450                                 break;
2451
2452                                 case 8:
2453                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2454                                 break;
2455
2456                                 case 9:
2457                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2458                                 break;
2459
2460                                 default:
2461                                 break;
2462
2463                         }
2464                 }
2465                 ndr->flags = _flags_save_UNION;
2466         }
2467         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2468         return NDR_ERR_SUCCESS;
2469 }
2470
2471 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2472 {
2473         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2474         int level;
2475         {
2476                 uint32_t _flags_save_UNION = ndr->flags;
2477                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
2478                 level = ndr_pull_get_switch_value(ndr, r);
2479                 if (ndr_flags & NDR_SCALARS) {
2480                         switch (level) {
2481                                 case 0: {
2482                                         NDR_CHECK(ndr_pull_align(ndr, 4));
2483                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2484                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2485                                 break; }
2486
2487                                 case 1: {
2488                                         NDR_CHECK(ndr_pull_align(ndr, 4));
2489                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2490                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2491                                 break; }
2492
2493                                 case 2: {
2494                                         NDR_CHECK(ndr_pull_align(ndr, 4));
2495                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2496                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2497                                 break; }
2498
2499                                 case 3: {
2500                                         NDR_CHECK(ndr_pull_align(ndr, 4));
2501                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2502                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2503                                 break; }
2504
2505                                 case 4: {
2506                                         NDR_CHECK(ndr_pull_align(ndr, 4));
2507                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2508                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2509                                 break; }
2510
2511                                 case 5: {
2512                                         NDR_CHECK(ndr_pull_align(ndr, 4));
2513                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2514                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2515                                 break; }
2516
2517                                 case 6: {
2518                                         NDR_CHECK(ndr_pull_align(ndr, 4));
2519                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2520                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2521                                 break; }
2522
2523                                 case 7: {
2524                                         NDR_CHECK(ndr_pull_align(ndr, 4));
2525                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2526                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2527                                 break; }
2528
2529                                 case 8: {
2530                                         NDR_CHECK(ndr_pull_align(ndr, 4));
2531                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2532                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2533                                 break; }
2534
2535                                 case 9: {
2536                                         NDR_CHECK(ndr_pull_align(ndr, 4));
2537                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2538                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2539                                 break; }
2540
2541                                 default: {
2542                                 break; }
2543
2544                         }
2545                 }
2546                 if (ndr_flags & NDR_BUFFERS) {
2547                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2548                         switch (level) {
2549                                 case 0:
2550                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2551                                 break;
2552
2553                                 case 1:
2554                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2555                                 break;
2556
2557                                 case 2:
2558                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2559                                 break;
2560
2561                                 case 3:
2562                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2563                                 break;
2564
2565                                 case 4:
2566                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2567                                 break;
2568
2569                                 case 5:
2570                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2571                                 break;
2572
2573                                 case 6:
2574                                 break;
2575
2576                                 case 7:
2577                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2578                                 break;
2579
2580                                 case 8:
2581                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2582                                 break;
2583
2584                                 case 9:
2585                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2586                                 break;
2587
2588                                 default:
2589                                 break;
2590
2591                         }
2592                 }
2593                 ndr->flags = _flags_save_UNION;
2594         }
2595         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2596         return NDR_ERR_SUCCESS;
2597 }
2598
2599 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2600 {
2601         int level;
2602         {
2603                 uint32_t _flags_save_UNION = ndr->flags;
2604                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
2605                 level = ndr_print_get_switch_value(ndr, r);
2606                 ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2607                 switch (level) {
2608                         case 0:
2609                                 ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2610                         break;
2611
2612                         case 1:
2613                                 ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2614                         break;
2615
2616                         case 2:
2617                                 ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2618                         break;
2619
2620                         case 3:
2621                                 ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2622                         break;
2623
2624                         case 4:
2625                                 ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2626                         break;
2627
2628                         case 5:
2629                                 ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2630                         break;
2631
2632                         case 6:
2633                                 ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2634                         break;
2635
2636                         case 7:
2637                                 ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2638                         break;
2639
2640                         case 8:
2641                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2642                         break;
2643
2644                         case 9:
2645                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2646                         break;
2647
2648                         default:
2649                         break;
2650
2651                 }
2652                 ndr->flags = _flags_save_UNION;
2653         }
2654 }
2655
2656 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo(const union spoolss_PrinterInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
2657 {
2658         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
2659         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo, ic);
2660 }
2661
2662 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
2663 {
2664         if (ndr_flags & NDR_SCALARS) {
2665                 NDR_CHECK(ndr_push_align(ndr, 4));
2666                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2667                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
2668         }
2669         if (ndr_flags & NDR_BUFFERS) {
2670                 if (r->devmode) {
2671                         {
2672                                 struct ndr_push *_ndr_devmode;
2673                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2674                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2675                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2676                         }
2677                 }
2678         }
2679         return NDR_ERR_SUCCESS;
2680 }
2681
2682 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
2683 {
2684         uint32_t _ptr_devmode;
2685         TALLOC_CTX *_mem_save_devmode_0;
2686         if (ndr_flags & NDR_SCALARS) {
2687                 NDR_CHECK(ndr_pull_align(ndr, 4));
2688                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
2689                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2690                 if (_ptr_devmode) {
2691                         NDR_PULL_ALLOC(ndr, r->devmode);
2692                 } else {
2693                         r->devmode = NULL;
2694                 }
2695         }
2696         if (ndr_flags & NDR_BUFFERS) {
2697                 if (r->devmode) {
2698                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2699                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2700                         {
2701                                 struct ndr_pull *_ndr_devmode;
2702                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
2703                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2704                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
2705                         }
2706                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2707                 }
2708         }
2709         return NDR_ERR_SUCCESS;
2710 }
2711
2712 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
2713 {
2714         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
2715         ndr->depth++;
2716         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?_ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
2717         ndr_print_ptr(ndr, "devmode", r->devmode);
2718         ndr->depth++;
2719         if (r->devmode) {
2720                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2721         }
2722         ndr->depth--;
2723         ndr->depth--;
2724 }
2725
2726 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
2727 {
2728         if (ndr_flags & NDR_SCALARS) {
2729                 NDR_CHECK(ndr_push_align(ndr, 4));
2730                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2731                 {
2732                         uint32_t _flags_save_string = ndr->flags;
2733                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2734                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2735                         ndr->flags = _flags_save_string;
2736                 }
2737                 {
2738                         uint32_t _flags_save_string = ndr->flags;
2739                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2740                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2741                         ndr->flags = _flags_save_string;
2742                 }
2743                 {
2744                         uint32_t _flags_save_string = ndr->flags;
2745                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2746                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2747                         ndr->flags = _flags_save_string;
2748                 }
2749                 {
2750                         uint32_t _flags_save_string = ndr->flags;
2751                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2752                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2753                         ndr->flags = _flags_save_string;
2754                 }
2755                 {
2756                         uint32_t _flags_save_string = ndr->flags;
2757                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2758                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2759                         ndr->flags = _flags_save_string;
2760                 }
2761                 {
2762                         uint32_t _flags_save_string = ndr->flags;
2763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2764                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2765                         ndr->flags = _flags_save_string;
2766                 }
2767                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
2768                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2772                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2773         }
2774         if (ndr_flags & NDR_BUFFERS) {
2775                 {
2776                         uint32_t _flags_save_string = ndr->flags;
2777                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2778                         if (r->printer_name) {
2779                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
2780                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2781                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
2782                         }
2783                         ndr->flags = _flags_save_string;
2784                 }
2785                 {
2786                         uint32_t _flags_save_string = ndr->flags;
2787                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2788                         if (r->server_name) {
2789                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
2790                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2791                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
2792                         }
2793                         ndr->flags = _flags_save_string;
2794                 }
2795                 {
2796                         uint32_t _flags_save_string = ndr->flags;
2797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2798                         if (r->user_name) {
2799                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
2800                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
2801                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
2802                         }
2803                         ndr->flags = _flags_save_string;
2804                 }
2805                 {
2806                         uint32_t _flags_save_string = ndr->flags;
2807                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2808                         if (r->document_name) {
2809                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
2810                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
2811                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
2812                         }
2813                         ndr->flags = _flags_save_string;
2814                 }
2815                 {
2816                         uint32_t _flags_save_string = ndr->flags;
2817                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2818                         if (r->data_type) {
2819                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
2820                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
2821                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
2822                         }
2823                         ndr->flags = _flags_save_string;
2824                 }
2825                 {
2826                         uint32_t _flags_save_string = ndr->flags;
2827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2828                         if (r->text_status) {
2829                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
2830                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
2831                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
2832                         }
2833                         ndr->flags = _flags_save_string;
2834                 }
2835         }
2836         return NDR_ERR_SUCCESS;
2837 }
2838
2839 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
2840 {
2841         uint32_t _ptr_printer_name;
2842         TALLOC_CTX *_mem_save_printer_name_0;
2843         uint32_t _ptr_server_name;
2844         TALLOC_CTX *_mem_save_server_name_0;
2845         uint32_t _ptr_user_name;
2846         TALLOC_CTX *_mem_save_user_name_0;
2847         uint32_t _ptr_document_name;
2848         TALLOC_CTX *_mem_save_document_name_0;
2849         uint32_t _ptr_data_type;
2850         TALLOC_CTX *_mem_save_data_type_0;
2851         uint32_t _ptr_text_status;
2852         TALLOC_CTX *_mem_save_text_status_0;
2853         if (ndr_flags & NDR_SCALARS) {
2854                 NDR_CHECK(ndr_pull_align(ndr, 4));
2855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
2856                 {
2857                         uint32_t _flags_save_string = ndr->flags;
2858                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2859                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
2860                         if (_ptr_printer_name) {
2861                                 NDR_PULL_ALLOC(ndr, r->printer_name);
2862                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
2863                         } else {
2864                                 r->printer_name = NULL;
2865                         }
2866                         ndr->flags = _flags_save_string;
2867                 }
2868                 {
2869                         uint32_t _flags_save_string = ndr->flags;
2870                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2871                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2872                         if (_ptr_server_name) {
2873                                 NDR_PULL_ALLOC(ndr, r->server_name);
2874                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
2875                         } else {
2876                                 r->server_name = NULL;
2877                         }
2878                         ndr->flags = _flags_save_string;
2879                 }
2880                 {
2881                         uint32_t _flags_save_string = ndr->flags;
2882                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2883                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2884                         if (_ptr_user_name) {
2885                                 NDR_PULL_ALLOC(ndr, r->user_name);
2886                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
2887                         } else {
2888                                 r->user_name = NULL;
2889                         }
2890                         ndr->flags = _flags_save_string;
2891                 }
2892                 {
2893                         uint32_t _flags_save_string = ndr->flags;
2894                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2895                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
2896                         if (_ptr_document_name) {
2897                                 NDR_PULL_ALLOC(ndr, r->document_name);
2898                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
2899                         } else {
2900                                 r->document_name = NULL;
2901                         }
2902                         ndr->flags = _flags_save_string;
2903                 }
2904                 {
2905                         uint32_t _flags_save_string = ndr->flags;
2906                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2907                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
2908                         if (_ptr_data_type) {
2909                                 NDR_PULL_ALLOC(ndr, r->data_type);
2910                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
2911                         } else {
2912                                 r->data_type = NULL;
2913                         }
2914                         ndr->flags = _flags_save_string;
2915                 }
2916                 {
2917                         uint32_t _flags_save_string = ndr->flags;
2918                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2919                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
2920                         if (_ptr_text_status) {
2921                                 NDR_PULL_ALLOC(ndr, r->text_status);
2922                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
2923                         } else {
2924                                 r->text_status = NULL;
2925                         }
2926                         ndr->flags = _flags_save_string;
2927                 }
2928                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
2929                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
2930                 if (r->priority > 99) {
2931                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2932                 }
2933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
2934                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
2935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
2936                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2937         }
2938         if (ndr_flags & NDR_BUFFERS) {
2939                 {
2940                         uint32_t _flags_save_string = ndr->flags;
2941                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2942                         if (r->printer_name) {
2943                                 uint32_t _relative_save_offset;
2944                                 _relative_save_offset = ndr->offset;
2945                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
2946                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2947                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
2948                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
2949                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
2950                                 ndr->offset = _relative_save_offset;
2951                         }
2952                         ndr->flags = _flags_save_string;
2953                 }
2954                 {
2955                         uint32_t _flags_save_string = ndr->flags;
2956                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2957                         if (r->server_name) {
2958                                 uint32_t _relative_save_offset;
2959                                 _relative_save_offset = ndr->offset;
2960                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
2961                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2962                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
2963                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
2964                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2965                                 ndr->offset = _relative_save_offset;
2966                         }
2967                         ndr->flags = _flags_save_string;
2968                 }
2969                 {
2970                         uint32_t _flags_save_string = ndr->flags;
2971                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2972                         if (r->user_name) {
2973                                 uint32_t _relative_save_offset;
2974                                 _relative_save_offset = ndr->offset;
2975                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
2976                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2977                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2978                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
2979                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2980                                 ndr->offset = _relative_save_offset;
2981                         }
2982                         ndr->flags = _flags_save_string;
2983                 }
2984                 {
2985                         uint32_t _flags_save_string = ndr->flags;
2986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2987                         if (r->document_name) {
2988                                 uint32_t _relative_save_offset;
2989                                 _relative_save_offset = ndr->offset;
2990                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
2991                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2992                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
2993                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
2994                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
2995                                 ndr->offset = _relative_save_offset;
2996                         }
2997                         ndr->flags = _flags_save_string;
2998                 }
2999                 {
3000                         uint32_t _flags_save_string = ndr->flags;
3001                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3002                         if (r->data_type) {
3003                                 uint32_t _relative_save_offset;
3004                                 _relative_save_offset = ndr->offset;
3005                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3006                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3007                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3008                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3009                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3010                                 ndr->offset = _relative_save_offset;
3011                         }
3012                         ndr->flags = _flags_save_string;
3013                 }
3014                 {
3015                         uint32_t _flags_save_string = ndr->flags;
3016                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3017                         if (r->text_status) {
3018                                 uint32_t _relative_save_offset;
3019                                 _relative_save_offset = ndr->offset;
3020                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3021                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3022                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3023                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3024                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3025                                 ndr->offset = _relative_save_offset;
3026                         }
3027                         ndr->flags = _flags_save_string;
3028                 }
3029         }
3030         return NDR_ERR_SUCCESS;
3031 }
3032
3033 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
3034 {
3035         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
3036         ndr->depth++;
3037         ndr_print_uint32(ndr, "job_id", r->job_id);
3038         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3039         ndr->depth++;
3040         if (r->printer_name) {
3041                 ndr_print_string(ndr, "printer_name", r->printer_name);
3042         }
3043         ndr->depth--;
3044         ndr_print_ptr(ndr, "server_name", r->server_name);
3045         ndr->depth++;
3046         if (r->server_name) {
3047                 ndr_print_string(ndr, "server_name", r->server_name);
3048         }
3049         ndr->depth--;
3050         ndr_print_ptr(ndr, "user_name", r->user_name);
3051         ndr->depth++;
3052         if (r->user_name) {
3053                 ndr_print_string(ndr, "user_name", r->user_name);
3054         }
3055         ndr->depth--;
3056         ndr_print_ptr(ndr, "document_name", r->document_name);
3057         ndr->depth++;
3058         if (r->document_name) {
3059                 ndr_print_string(ndr, "document_name", r->document_name);
3060         }
3061         ndr->depth--;
3062         ndr_print_ptr(ndr, "data_type", r->data_type);
3063         ndr->depth++;
3064         if (r->data_type) {
3065                 ndr_print_string(ndr, "data_type", r->data_type);
3066         }
3067         ndr->depth--;
3068         ndr_print_ptr(ndr, "text_status", r->text_status);
3069         ndr->depth++;
3070         if (r->text_status) {
3071                 ndr_print_string(ndr, "text_status", r->text_status);
3072         }
3073         ndr->depth--;
3074         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3075         ndr_print_uint32(ndr, "priority", r->priority);
3076         ndr_print_uint32(ndr, "position", r->position);
3077         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3078         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3079         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3080         ndr->depth--;
3081 }
3082
3083 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
3084 {
3085         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
3086 }
3087
3088 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
3089 {
3090         if (ndr_flags & NDR_SCALARS) {
3091                 NDR_CHECK(ndr_push_align(ndr, 4));
3092                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3093                 {
3094                         uint32_t _flags_save_string = ndr->flags;
3095                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3096                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3097                         ndr->flags = _flags_save_string;
3098                 }
3099                 {
3100                         uint32_t _flags_save_string = ndr->flags;
3101                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3102                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3103                         ndr->flags = _flags_save_string;
3104                 }
3105                 {
3106                         uint32_t _flags_save_string = ndr->flags;
3107                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3108                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3109                         ndr->flags = _flags_save_string;
3110                 }
3111                 {
3112                         uint32_t _flags_save_string = ndr->flags;
3113                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3114                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3115                         ndr->flags = _flags_save_string;
3116                 }
3117                 {
3118                         uint32_t _flags_save_string = ndr->flags;
3119                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3120                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3121                         ndr->flags = _flags_save_string;
3122                 }
3123                 {
3124                         uint32_t _flags_save_string = ndr->flags;
3125                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3126                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3127                         ndr->flags = _flags_save_string;
3128                 }
3129                 {
3130                         uint32_t _flags_save_string = ndr->flags;
3131                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3132                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3133                         ndr->flags = _flags_save_string;
3134                 }
3135                 {
3136                         uint32_t _flags_save_string = ndr->flags;
3137                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3138                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3139                         ndr->flags = _flags_save_string;
3140                 }
3141                 {
3142                         uint32_t _flags_save_string = ndr->flags;
3143                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3144                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3145                         ndr->flags = _flags_save_string;
3146                 }
3147                 {
3148                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3149                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3150                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3151                         ndr->flags = _flags_save_spoolss_DeviceMode;
3152                 }
3153                 {
3154                         uint32_t _flags_save_string = ndr->flags;
3155                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3156                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3157                         ndr->flags = _flags_save_string;
3158                 }
3159                 {
3160                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3161                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3162                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3163                         ndr->flags = _flags_save_spoolss_security_descriptor;
3164                 }
3165                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3168                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3172                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3175         }
3176         if (ndr_flags & NDR_BUFFERS) {
3177                 {
3178                         uint32_t _flags_save_string = ndr->flags;
3179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3180                         if (r->printer_name) {
3181                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
3182                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3183                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
3184                         }
3185                         ndr->flags = _flags_save_string;
3186                 }
3187                 {
3188                         uint32_t _flags_save_string = ndr->flags;
3189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3190                         if (r->server_name) {
3191                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
3192                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3193                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
3194                         }
3195                         ndr->flags = _flags_save_string;
3196                 }
3197                 {
3198                         uint32_t _flags_save_string = ndr->flags;
3199                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3200                         if (r->user_name) {
3201                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
3202                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3203                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
3204                         }
3205                         ndr->flags = _flags_save_string;
3206                 }
3207                 {
3208                         uint32_t _flags_save_string = ndr->flags;
3209                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3210                         if (r->document_name) {
3211                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
3212                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3213                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
3214                         }
3215                         ndr->flags = _flags_save_string;
3216                 }
3217                 {
3218                         uint32_t _flags_save_string = ndr->flags;
3219                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3220                         if (r->notify_name) {
3221                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->notify_name));
3222                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3223                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->notify_name));
3224                         }
3225                         ndr->flags = _flags_save_string;
3226                 }
3227                 {
3228                         uint32_t _flags_save_string = ndr->flags;
3229                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3230                         if (r->data_type) {
3231                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
3232                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3233                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
3234                         }
3235                         ndr->flags = _flags_save_string;
3236                 }
3237                 {
3238                         uint32_t _flags_save_string = ndr->flags;
3239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3240                         if (r->print_processor) {
3241                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
3242                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3243                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
3244                         }
3245                         ndr->flags = _flags_save_string;
3246                 }
3247                 {
3248                         uint32_t _flags_save_string = ndr->flags;
3249                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3250                         if (r->parameters) {
3251                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->parameters));
3252                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3253                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->parameters));
3254                         }
3255                         ndr->flags = _flags_save_string;
3256                 }
3257                 {
3258                         uint32_t _flags_save_string = ndr->flags;
3259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3260                         if (r->driver_name) {
3261                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
3262                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3263                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
3264                         }
3265                         ndr->flags = _flags_save_string;
3266                 }
3267                 {
3268                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3270                         if (r->devmode) {
3271                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
3272                                 {
3273                                         struct ndr_push *_ndr_devmode;
3274                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
3275                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3276                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
3277                                 }
3278                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
3279                         }
3280                         ndr->flags = _flags_save_spoolss_DeviceMode;
3281                 }
3282                 {
3283                         uint32_t _flags_save_string = ndr->flags;
3284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3285                         if (r->text_status) {
3286                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
3287                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3288                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
3289                         }
3290                         ndr->flags = _flags_save_string;
3291                 }
3292                 {
3293                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3295                         if (r->secdesc) {
3296                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
3297                                 {
3298                                         struct ndr_push *_ndr_secdesc;
3299                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
3300                                         NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3301                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
3302                                 }
3303                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
3304                         }
3305                         ndr->flags = _flags_save_spoolss_security_descriptor;
3306                 }
3307         }
3308         return NDR_ERR_SUCCESS;
3309 }
3310
3311 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3312 {
3313         uint32_t _ptr_printer_name;
3314         TALLOC_CTX *_mem_save_printer_name_0;
3315         uint32_t _ptr_server_name;
3316         TALLOC_CTX *_mem_save_server_name_0;
3317         uint32_t _ptr_user_name;
3318         TALLOC_CTX *_mem_save_user_name_0;
3319         uint32_t _ptr_document_name;
3320         TALLOC_CTX *_mem_save_document_name_0;
3321         uint32_t _ptr_notify_name;
3322         TALLOC_CTX *_mem_save_notify_name_0;
3323         uint32_t _ptr_data_type;
3324         TALLOC_CTX *_mem_save_data_type_0;
3325         uint32_t _ptr_print_processor;
3326         TALLOC_CTX *_mem_save_print_processor_0;
3327         uint32_t _ptr_parameters;
3328         TALLOC_CTX *_mem_save_parameters_0;
3329         uint32_t _ptr_driver_name;
3330         TALLOC_CTX *_mem_save_driver_name_0;
3331         uint32_t _ptr_devmode;
3332         TALLOC_CTX *_mem_save_devmode_0;
3333         uint32_t _ptr_text_status;
3334         TALLOC_CTX *_mem_save_text_status_0;
3335         uint32_t _ptr_secdesc;
3336         TALLOC_CTX *_mem_save_secdesc_0;
3337         if (ndr_flags & NDR_SCALARS) {
3338                 NDR_CHECK(ndr_pull_align(ndr, 4));
3339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3340                 {
3341                         uint32_t _flags_save_string = ndr->flags;
3342                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3343                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3344                         if (_ptr_printer_name) {
3345                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3346                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3347                         } else {
3348                                 r->printer_name = NULL;
3349                         }
3350                         ndr->flags = _flags_save_string;
3351                 }
3352                 {
3353                         uint32_t _flags_save_string = ndr->flags;
3354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3355                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3356                         if (_ptr_server_name) {
3357                                 NDR_PULL_ALLOC(ndr, r->server_name);
3358                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3359                         } else {
3360                                 r->server_name = NULL;
3361                         }
3362                         ndr->flags = _flags_save_string;
3363                 }
3364                 {
3365                         uint32_t _flags_save_string = ndr->flags;
3366                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3367                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3368                         if (_ptr_user_name) {
3369                                 NDR_PULL_ALLOC(ndr, r->user_name);
3370                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3371                         } else {
3372                                 r->user_name = NULL;
3373                         }
3374                         ndr->flags = _flags_save_string;
3375                 }
3376                 {
3377                         uint32_t _flags_save_string = ndr->flags;
3378                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3379                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3380                         if (_ptr_document_name) {
3381                                 NDR_PULL_ALLOC(ndr, r->document_name);
3382                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3383                         } else {
3384                                 r->document_name = NULL;
3385                         }
3386                         ndr->flags = _flags_save_string;
3387                 }
3388                 {
3389                         uint32_t _flags_save_string = ndr->flags;
3390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3391                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3392                         if (_ptr_notify_name) {
3393                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3394                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3395                         } else {
3396                                 r->notify_name = NULL;
3397                         }
3398                         ndr->flags = _flags_save_string;
3399                 }
3400                 {
3401                         uint32_t _flags_save_string = ndr->flags;
3402                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3403                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3404                         if (_ptr_data_type) {
3405                                 NDR_PULL_ALLOC(ndr, r->data_type);
3406                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3407                         } else {
3408                                 r->data_type = NULL;
3409                         }
3410                         ndr->flags = _flags_save_string;
3411                 }
3412                 {
3413                         uint32_t _flags_save_string = ndr->flags;
3414                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3415                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3416                         if (_ptr_print_processor) {
3417                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3418                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3419                         } else {
3420                                 r->print_processor = NULL;
3421                         }
3422                         ndr->flags = _flags_save_string;
3423                 }
3424                 {
3425                         uint32_t _flags_save_string = ndr->flags;
3426                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3427                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3428                         if (_ptr_parameters) {
3429                                 NDR_PULL_ALLOC(ndr, r->parameters);
3430                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3431                         } else {
3432                                 r->parameters = NULL;
3433                         }
3434                         ndr->flags = _flags_save_string;
3435                 }
3436                 {
3437                         uint32_t _flags_save_string = ndr->flags;
3438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3439                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3440                         if (_ptr_driver_name) {
3441                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3442                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3443                         } else {
3444                                 r->driver_name = NULL;
3445                         }
3446                         ndr->flags = _flags_save_string;
3447                 }
3448                 {
3449                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3450                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3451                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3452                         if (_ptr_devmode) {
3453                                 NDR_PULL_ALLOC(ndr, r->devmode);
3454                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3455                         } else {
3456                                 r->devmode = NULL;
3457                         }
3458                         ndr->flags = _flags_save_spoolss_DeviceMode;
3459                 }
3460                 {
3461                         uint32_t _flags_save_string = ndr->flags;
3462                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3463                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3464                         if (_ptr_text_status) {
3465                                 NDR_PULL_ALLOC(ndr, r->text_status);
3466                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3467                         } else {
3468                                 r->text_status = NULL;
3469                         }
3470                         ndr->flags = _flags_save_string;
3471                 }
3472                 {
3473                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3474                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3475                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3476                         if (_ptr_secdesc) {
3477                                 NDR_PULL_ALLOC(ndr, r->secdesc);
3478                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3479                         } else {
3480                                 r->secdesc = NULL;
3481                         }
3482                         ndr->flags = _flags_save_spoolss_security_descriptor;
3483                 }
3484                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3485                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3486                 if (r->priority > 99) {
3487                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3488                 }
3489                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3494                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3496                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3497         }
3498         if (ndr_flags & NDR_BUFFERS) {
3499                 {
3500                         uint32_t _flags_save_string = ndr->flags;
3501                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3502                         if (r->printer_name) {
3503                                 uint32_t _relative_save_offset;
3504                                 _relative_save_offset = ndr->offset;
3505                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3506                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3507                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3508                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3509                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3510                                 ndr->offset = _relative_save_offset;
3511                         }
3512                         ndr->flags = _flags_save_string;
3513                 }
3514                 {
3515                         uint32_t _flags_save_string = ndr->flags;
3516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3517                         if (r->server_name) {
3518                                 uint32_t _relative_save_offset;
3519                                 _relative_save_offset = ndr->offset;
3520                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3521                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3522                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3523                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3524                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3525                                 ndr->offset = _relative_save_offset;
3526                         }
3527                         ndr->flags = _flags_save_string;
3528                 }
3529                 {
3530                         uint32_t _flags_save_string = ndr->flags;
3531                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3532                         if (r->user_name) {
3533                                 uint32_t _relative_save_offset;
3534                                 _relative_save_offset = ndr->offset;
3535                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3536                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3537                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3538                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3539                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3540                                 ndr->offset = _relative_save_offset;
3541                         }
3542                         ndr->flags = _flags_save_string;
3543                 }
3544                 {
3545                         uint32_t _flags_save_string = ndr->flags;
3546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3547                         if (r->document_name) {
3548                                 uint32_t _relative_save_offset;
3549                                 _relative_save_offset = ndr->offset;
3550                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3551                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3552                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3553                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3554                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3555                                 ndr->offset = _relative_save_offset;
3556                         }
3557                         ndr->flags = _flags_save_string;
3558                 }
3559                 {
3560                         uint32_t _flags_save_string = ndr->flags;
3561                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3562                         if (r->notify_name) {
3563                                 uint32_t _relative_save_offset;
3564                                 _relative_save_offset = ndr->offset;
3565                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3566                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3567                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3568                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3569                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3570                                 ndr->offset = _relative_save_offset;
3571                         }
3572                         ndr->flags = _flags_save_string;
3573                 }
3574                 {
3575                         uint32_t _flags_save_string = ndr->flags;
3576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3577                         if (r->data_type) {
3578                                 uint32_t _relative_save_offset;
3579                                 _relative_save_offset = ndr->offset;
3580                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3581                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3582                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3583                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3584                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3585                                 ndr->offset = _relative_save_offset;
3586                         }
3587                         ndr->flags = _flags_save_string;
3588                 }
3589                 {
3590                         uint32_t _flags_save_string = ndr->flags;
3591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3592                         if (r->print_processor) {
3593                                 uint32_t _relative_save_offset;
3594                                 _relative_save_offset = ndr->offset;
3595                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
3596                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3597                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
3598                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
3599                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
3600                                 ndr->offset = _relative_save_offset;
3601                         }
3602                         ndr->flags = _flags_save_string;
3603                 }
3604                 {
3605                         uint32_t _flags_save_string = ndr->flags;
3606                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3607                         if (r->parameters) {
3608                                 uint32_t _relative_save_offset;
3609                                 _relative_save_offset = ndr->offset;
3610                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
3611                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3612                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3613                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
3614                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3615                                 ndr->offset = _relative_save_offset;
3616                         }
3617                         ndr->flags = _flags_save_string;
3618                 }
3619                 {
3620                         uint32_t _flags_save_string = ndr->flags;
3621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3622                         if (r->driver_name) {
3623                                 uint32_t _relative_save_offset;
3624                                 _relative_save_offset = ndr->offset;
3625                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
3626                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3627                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
3628                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
3629                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
3630                                 ndr->offset = _relative_save_offset;
3631                         }
3632                         ndr->flags = _flags_save_string;
3633                 }
3634                 {
3635                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3637                         if (r->devmode) {
3638                                 uint32_t _relative_save_offset;
3639                                 _relative_save_offset = ndr->offset;
3640                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
3641                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3642                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3643                                 {
3644                                         struct ndr_pull *_ndr_devmode;
3645                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
3646                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3647                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
3648                                 }
3649                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3650                                 ndr->offset = _relative_save_offset;
3651                         }
3652                         ndr->flags = _flags_save_spoolss_DeviceMode;
3653                 }
3654                 {
3655                         uint32_t _flags_save_string = ndr->flags;
3656                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3657                         if (r->text_status) {
3658                                 uint32_t _relative_save_offset;
3659                                 _relative_save_offset = ndr->offset;
3660                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3661                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3662                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3663                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3664                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3665                                 ndr->offset = _relative_save_offset;
3666                         }
3667                         ndr->flags = _flags_save_string;
3668                 }
3669                 {
3670                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3672                         if (r->secdesc) {
3673                                 uint32_t _relative_save_offset;
3674                                 _relative_save_offset = ndr->offset;
3675                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
3676                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3677                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3678                                 {
3679                                         struct ndr_pull *_ndr_secdesc;
3680                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
3681                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3682                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
3683                                 }
3684                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3685                                 ndr->offset = _relative_save_offset;
3686                         }
3687                         ndr->flags = _flags_save_spoolss_security_descriptor;
3688                 }
3689         }
3690         return NDR_ERR_SUCCESS;
3691 }
3692
3693 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
3694 {
3695         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
3696         ndr->depth++;
3697         ndr_print_uint32(ndr, "job_id", r->job_id);
3698         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3699         ndr->depth++;
3700         if (r->printer_name) {
3701                 ndr_print_string(ndr, "printer_name", r->printer_name);
3702         }
3703         ndr->depth--;
3704         ndr_print_ptr(ndr, "server_name", r->server_name);
3705         ndr->depth++;
3706         if (r->server_name) {
3707                 ndr_print_string(ndr, "server_name", r->server_name);
3708         }
3709         ndr->depth--;
3710         ndr_print_ptr(ndr, "user_name", r->user_name);
3711         ndr->depth++;
3712         if (r->user_name) {
3713                 ndr_print_string(ndr, "user_name", r->user_name);
3714         }
3715         ndr->depth--;
3716         ndr_print_ptr(ndr, "document_name", r->document_name);
3717         ndr->depth++;
3718         if (r->document_name) {
3719                 ndr_print_string(ndr, "document_name", r->document_name);
3720         }
3721         ndr->depth--;
3722         ndr_print_ptr(ndr, "notify_name", r->notify_name);
3723         ndr->depth++;
3724         if (r->notify_name) {
3725                 ndr_print_string(ndr, "notify_name", r->notify_name);
3726         }
3727         ndr->depth--;
3728         ndr_print_ptr(ndr, "data_type", r->data_type);
3729         ndr->depth++;
3730         if (r->data_type) {
3731                 ndr_print_string(ndr, "data_type", r->data_type);
3732         }
3733         ndr->depth--;
3734         ndr_print_ptr(ndr, "print_processor", r->print_processor);
3735         ndr->depth++;
3736         if (r->print_processor) {
3737                 ndr_print_string(ndr, "print_processor", r->print_processor);
3738         }
3739         ndr->depth--;
3740         ndr_print_ptr(ndr, "parameters", r->parameters);
3741         ndr->depth++;
3742         if (r->parameters) {
3743                 ndr_print_string(ndr, "parameters", r->parameters);
3744         }
3745         ndr->depth--;
3746         ndr_print_ptr(ndr, "driver_name", r->driver_name);
3747         ndr->depth++;
3748         if (r->driver_name) {
3749                 ndr_print_string(ndr, "driver_name", r->driver_name);
3750         }
3751         ndr->depth--;
3752         ndr_print_ptr(ndr, "devmode", r->devmode);
3753         ndr->depth++;
3754         if (r->devmode) {
3755                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3756         }
3757         ndr->depth--;
3758         ndr_print_ptr(ndr, "text_status", r->text_status);
3759         ndr->depth++;
3760         if (r->text_status) {
3761                 ndr_print_string(ndr, "text_status", r->text_status);
3762         }
3763         ndr->depth--;
3764         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3765         ndr->depth++;
3766         if (r->secdesc) {
3767                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
3768         }
3769         ndr->depth--;
3770         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3771         ndr_print_uint32(ndr, "priority", r->priority);
3772         ndr_print_uint32(ndr, "position", r->position);
3773         ndr_print_uint32(ndr, "start_time", r->start_time);
3774         ndr_print_uint32(ndr, "until_time", r->until_time);
3775         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3776         ndr_print_uint32(ndr, "size", r->size);
3777         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3778         ndr_print_uint32(ndr, "time", r->time);
3779         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3780         ndr->depth--;
3781 }
3782
3783 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
3784 {
3785         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
3786 }
3787
3788 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
3789 {
3790         if (ndr_flags & NDR_SCALARS) {
3791                 NDR_CHECK(ndr_push_align(ndr, 4));
3792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
3794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
3795         }
3796         if (ndr_flags & NDR_BUFFERS) {
3797         }
3798         return NDR_ERR_SUCCESS;
3799 }
3800
3801 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
3802 {
3803         if (ndr_flags & NDR_SCALARS) {
3804                 NDR_CHECK(ndr_pull_align(ndr, 4));
3805                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
3807                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
3808         }
3809         if (ndr_flags & NDR_BUFFERS) {
3810         }
3811         return NDR_ERR_SUCCESS;
3812 }
3813
3814 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
3815 {
3816         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
3817         ndr->depth++;
3818         ndr_print_uint32(ndr, "job_id", r->job_id);
3819         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
3820         ndr_print_uint32(ndr, "reserved", r->reserved);
3821         ndr->depth--;
3822 }
3823
3824 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
3825 {
3826         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
3827 }
3828
3829 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
3830 {
3831         if (ndr_flags & NDR_SCALARS) {
3832                 NDR_CHECK(ndr_push_align(ndr, 4));
3833                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3834                 {
3835                         uint32_t _flags_save_string = ndr->flags;
3836                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3837                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3838                         ndr->flags = _flags_save_string;
3839                 }
3840                 {
3841                         uint32_t _flags_save_string = ndr->flags;
3842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3843                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3844                         ndr->flags = _flags_save_string;
3845                 }
3846                 {
3847                         uint32_t _flags_save_string = ndr->flags;
3848                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3849                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3850                         ndr->flags = _flags_save_string;
3851                 }
3852                 {
3853                         uint32_t _flags_save_string = ndr->flags;
3854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3855                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3856                         ndr->flags = _flags_save_string;
3857                 }
3858                 {
3859                         uint32_t _flags_save_string = ndr->flags;
3860                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3861                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3862                         ndr->flags = _flags_save_string;
3863                 }
3864                 {
3865                         uint32_t _flags_save_string = ndr->flags;
3866                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3867                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3868                         ndr->flags = _flags_save_string;
3869                 }
3870                 {
3871                         uint32_t _flags_save_string = ndr->flags;
3872                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3873                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3874                         ndr->flags = _flags_save_string;
3875                 }
3876                 {
3877                         uint32_t _flags_save_string = ndr->flags;
3878                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3879                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3880                         ndr->flags = _flags_save_string;
3881                 }
3882                 {
3883                         uint32_t _flags_save_string = ndr->flags;
3884                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3885                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3886                         ndr->flags = _flags_save_string;
3887                 }
3888                 {
3889                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3890                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3891                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3892                         ndr->flags = _flags_save_spoolss_DeviceMode;
3893                 }
3894                 {
3895                         uint32_t _flags_save_string = ndr->flags;
3896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3897                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3898                         ndr->flags = _flags_save_string;
3899                 }
3900                 {
3901                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3902                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3903                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3904                         ndr->flags = _flags_save_spoolss_security_descriptor;
3905                 }
3906                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3912                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3913                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
3917         }
3918         if (ndr_flags & NDR_BUFFERS) {
3919                 {
3920                         uint32_t _flags_save_string = ndr->flags;
3921                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3922                         if (r->printer_name) {
3923                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
3924                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3925                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
3926                         }
3927                         ndr->flags = _flags_save_string;
3928                 }
3929                 {
3930                         uint32_t _flags_save_string = ndr->flags;
3931                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3932                         if (r->server_name) {
3933                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
3934                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3935                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
3936                         }
3937                         ndr->flags = _flags_save_string;
3938                 }
3939                 {
3940                         uint32_t _flags_save_string = ndr->flags;
3941                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3942                         if (r->user_name) {
3943                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
3944                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3945                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
3946                         }
3947                         ndr->flags = _flags_save_string;
3948                 }
3949                 {
3950                         uint32_t _flags_save_string = ndr->flags;
3951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3952                         if (r->document_name) {
3953                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
3954                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3955                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
3956                         }
3957                         ndr->flags = _flags_save_string;
3958                 }
3959                 {
3960                         uint32_t _flags_save_string = ndr->flags;
3961                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3962                         if (r->notify_name) {
3963                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->notify_name));
3964                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3965                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->notify_name));
3966                         }
3967                         ndr->flags = _flags_save_string;
3968                 }
3969                 {
3970                         uint32_t _flags_save_string = ndr->flags;
3971                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3972                         if (r->data_type) {
3973                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
3974                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3975                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
3976                         }
3977                         ndr->flags = _flags_save_string;
3978                 }
3979                 {
3980                         uint32_t _flags_save_string = ndr->flags;
3981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3982                         if (r->print_processor) {
3983                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
3984                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3985                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
3986                         }
3987                         ndr->flags = _flags_save_string;
3988                 }
3989                 {
3990                         uint32_t _flags_save_string = ndr->flags;
3991                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3992                         if (r->parameters) {
3993                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->parameters));
3994                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3995                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->parameters));
3996                         }
3997                         ndr->flags = _flags_save_string;
3998                 }
3999                 {
4000                         uint32_t _flags_save_string = ndr->flags;
4001                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4002                         if (r->driver_name) {
4003                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
4004                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
4005                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
4006                         }
4007                         ndr->flags = _flags_save_string;
4008                 }
4009                 {
4010                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4012                         if (r->devmode) {
4013                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
4014                                 {
4015                                         struct ndr_push *_ndr_devmode;
4016                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
4017                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
4018                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
4019                                 }
4020                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
4021                         }
4022                         ndr->flags = _flags_save_spoolss_DeviceMode;
4023                 }
4024                 {
4025                         uint32_t _flags_save_string = ndr->flags;
4026                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4027                         if (r->text_status) {
4028                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
4029                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
4030                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
4031                         }
4032                         ndr->flags = _flags_save_string;
4033                 }
4034                 {
4035                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4036                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4037                         if (r->secdesc) {
4038                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
4039                                 {
4040                                         struct ndr_push *_ndr_secdesc;
4041                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
4042                                         NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4043                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
4044                                 }
4045                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
4046                         }
4047                         ndr->flags = _flags_save_spoolss_security_descriptor;
4048                 }
4049         }
4050         return NDR_ERR_SUCCESS;
4051 }
4052
4053 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
4054 {
4055         uint32_t _ptr_printer_name;
4056         TALLOC_CTX *_mem_save_printer_name_0;
4057         uint32_t _ptr_server_name;
4058         TALLOC_CTX *_mem_save_server_name_0;
4059         uint32_t _ptr_user_name;
4060         TALLOC_CTX *_mem_save_user_name_0;
4061         uint32_t _ptr_document_name;
4062         TALLOC_CTX *_mem_save_document_name_0;
4063         uint32_t _ptr_notify_name;
4064         TALLOC_CTX *_mem_save_notify_name_0;
4065         uint32_t _ptr_data_type;
4066         TALLOC_CTX *_mem_save_data_type_0;
4067         uint32_t _ptr_print_processor;
4068         TALLOC_CTX *_mem_save_print_processor_0;
4069         uint32_t _ptr_parameters;
4070         TALLOC_CTX *_mem_save_parameters_0;
4071         uint32_t _ptr_driver_name;
4072         TALLOC_CTX *_mem_save_driver_name_0;
4073         uint32_t _ptr_devmode;
4074         TALLOC_CTX *_mem_save_devmode_0;
4075         uint32_t _ptr_text_status;
4076         TALLOC_CTX *_mem_save_text_status_0;
4077         uint32_t _ptr_secdesc;
4078         TALLOC_CTX *_mem_save_secdesc_0;
4079         if (ndr_flags & NDR_SCALARS) {
4080                 NDR_CHECK(ndr_pull_align(ndr, 4));
4081                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4082                 {
4083                         uint32_t _flags_save_string = ndr->flags;
4084                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4085                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4086                         if (_ptr_printer_name) {
4087                                 NDR_PULL_ALLOC(ndr, r->printer_name);
4088                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
4089                         } else {
4090                                 r->printer_name = NULL;
4091                         }
4092                         ndr->flags = _flags_save_string;
4093                 }
4094                 {
4095                         uint32_t _flags_save_string = ndr->flags;
4096                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4097                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4098                         if (_ptr_server_name) {
4099                                 NDR_PULL_ALLOC(ndr, r->server_name);
4100                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
4101                         } else {
4102                                 r->server_name = NULL;
4103                         }
4104                         ndr->flags = _flags_save_string;
4105                 }
4106                 {
4107                         uint32_t _flags_save_string = ndr->flags;
4108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4109                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4110                         if (_ptr_user_name) {
4111                                 NDR_PULL_ALLOC(ndr, r->user_name);
4112                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
4113                         } else {
4114                                 r->user_name = NULL;
4115                         }
4116                         ndr->flags = _flags_save_string;
4117                 }
4118                 {
4119                         uint32_t _flags_save_string = ndr->flags;
4120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4121                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4122                         if (_ptr_document_name) {
4123                                 NDR_PULL_ALLOC(ndr, r->document_name);
4124                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
4125                         } else {
4126                                 r->document_name = NULL;
4127                         }
4128                         ndr->flags = _flags_save_string;
4129                 }
4130                 {
4131                         uint32_t _flags_save_string = ndr->flags;
4132                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4133                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4134                         if (_ptr_notify_name) {
4135                                 NDR_PULL_ALLOC(ndr, r->notify_name);
4136                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
4137                         } else {
4138                                 r->notify_name = NULL;
4139                         }
4140                         ndr->flags = _flags_save_string;
4141                 }
4142                 {
4143                         uint32_t _flags_save_string = ndr->flags;
4144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4145                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4146                         if (_ptr_data_type) {
4147                                 NDR_PULL_ALLOC(ndr, r->data_type);
4148                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
4149                         } else {
4150                                 r->data_type = NULL;
4151                         }
4152                         ndr->flags = _flags_save_string;
4153                 }
4154                 {
4155                         uint32_t _flags_save_string = ndr->flags;
4156                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4157                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4158                         if (_ptr_print_processor) {
4159                                 NDR_PULL_ALLOC(ndr, r->print_processor);
4160                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
4161                         } else {
4162                                 r->print_processor = NULL;
4163                         }
4164                         ndr->flags = _flags_save_string;
4165                 }
4166                 {
4167                         uint32_t _flags_save_string = ndr->flags;
4168                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4169                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4170                         if (_ptr_parameters) {
4171                                 NDR_PULL_ALLOC(ndr, r->parameters);
4172                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
4173                         } else {
4174                                 r->parameters = NULL;
4175                         }
4176                         ndr->flags = _flags_save_string;
4177                 }
4178                 {
4179                         uint32_t _flags_save_string = ndr->flags;
4180                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4181                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4182                         if (_ptr_driver_name) {
4183                                 NDR_PULL_ALLOC(ndr, r->driver_name);
4184                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
4185                         } else {
4186                                 r->driver_name = NULL;
4187                         }
4188                         ndr->flags = _flags_save_string;
4189                 }
4190                 {
4191                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4192                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4193                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
4194                         if (_ptr_devmode) {
4195                                 NDR_PULL_ALLOC(ndr, r->devmode);
4196                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
4197                         } else {
4198                                 r->devmode = NULL;
4199                         }
4200                         ndr->flags = _flags_save_spoolss_DeviceMode;
4201                 }
4202                 {
4203                         uint32_t _flags_save_string = ndr->flags;
4204                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4205                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4206                         if (_ptr_text_status) {
4207                                 NDR_PULL_ALLOC(ndr, r->text_status);
4208                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
4209                         } else {
4210                                 r->text_status = NULL;
4211                         }
4212                         ndr->flags = _flags_save_string;
4213                 }
4214                 {
4215                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4216                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4217                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
4218                         if (_ptr_secdesc) {
4219                                 NDR_PULL_ALLOC(ndr, r->secdesc);
4220                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
4221                         } else {
4222                                 r->secdesc = NULL;
4223                         }
4224                         ndr->flags = _flags_save_spoolss_security_descriptor;
4225                 }
4226                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4227                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4228                 if (r->priority > 99) {
4229                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4230                 }
4231                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4233                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4234                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4235                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4236                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4239                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
4240         }
4241         if (ndr_flags & NDR_BUFFERS) {
4242                 {
4243                         uint32_t _flags_save_string = ndr->flags;
4244                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4245                         if (r->printer_name) {
4246                                 uint32_t _relative_save_offset;
4247                                 _relative_save_offset = ndr->offset;
4248                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
4249                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4250                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4251                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
4252                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4253                                 ndr->offset = _relative_save_offset;
4254                         }
4255                         ndr->flags = _flags_save_string;
4256                 }
4257                 {
4258                         uint32_t _flags_save_string = ndr->flags;
4259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4260                         if (r->server_name) {
4261                                 uint32_t _relative_save_offset;
4262                                 _relative_save_offset = ndr->offset;
4263                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4264                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4265                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4266                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4267                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4268                                 ndr->offset = _relative_save_offset;
4269                         }
4270                         ndr->flags = _flags_save_string;
4271                 }
4272                 {
4273                         uint32_t _flags_save_string = ndr->flags;
4274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4275                         if (r->user_name) {
4276                                 uint32_t _relative_save_offset;
4277                                 _relative_save_offset = ndr->offset;
4278                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4279                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4280                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4281                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4282                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4283                                 ndr->offset = _relative_save_offset;
4284                         }
4285                         ndr->flags = _flags_save_string;
4286                 }
4287                 {
4288                         uint32_t _flags_save_string = ndr->flags;
4289                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4290                         if (r->document_name) {
4291                                 uint32_t _relative_save_offset;
4292                                 _relative_save_offset = ndr->offset;
4293                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4294                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4295                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4296                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4297                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4298                                 ndr->offset = _relative_save_offset;
4299                         }
4300                         ndr->flags = _flags_save_string;
4301                 }
4302                 {
4303                         uint32_t _flags_save_string = ndr->flags;
4304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4305                         if (r->notify_name) {
4306                                 uint32_t _relative_save_offset;
4307                                 _relative_save_offset = ndr->offset;
4308                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4309                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4310                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4311                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4312                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4313                                 ndr->offset = _relative_save_offset;
4314                         }
4315                         ndr->flags = _flags_save_string;
4316                 }
4317                 {
4318                         uint32_t _flags_save_string = ndr->flags;
4319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4320                         if (r->data_type) {
4321                                 uint32_t _relative_save_offset;
4322                                 _relative_save_offset = ndr->offset;
4323                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4324                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4325                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4326                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4327                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4328                                 ndr->offset = _relative_save_offset;
4329                         }
4330                         ndr->flags = _flags_save_string;
4331                 }
4332                 {
4333                         uint32_t _flags_save_string = ndr->flags;
4334                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4335                         if (r->print_processor) {
4336                                 uint32_t _relative_save_offset;
4337                                 _relative_save_offset = ndr->offset;
4338                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4339                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4340                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4341                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4342                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4343                                 ndr->offset = _relative_save_offset;
4344                         }
4345                         ndr->flags = _flags_save_string;
4346                 }
4347                 {
4348                         uint32_t _flags_save_string = ndr->flags;
4349                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4350                         if (r->parameters) {
4351                                 uint32_t _relative_save_offset;
4352                                 _relative_save_offset = ndr->offset;
4353                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4354                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4355                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4356                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4357                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4358                                 ndr->offset = _relative_save_offset;
4359                         }
4360                         ndr->flags = _flags_save_string;
4361                 }
4362                 {
4363                         uint32_t _flags_save_string = ndr->flags;
4364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4365                         if (r->driver_name) {
4366                                 uint32_t _relative_save_offset;
4367                                 _relative_save_offset = ndr->offset;
4368                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4369                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4370                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4371                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4372                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4373                                 ndr->offset = _relative_save_offset;
4374                         }
4375                         ndr->flags = _flags_save_string;
4376                 }
4377                 {
4378                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4379                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4380                         if (r->devmode) {
4381                                 uint32_t _relative_save_offset;
4382                                 _relative_save_offset = ndr->offset;
4383                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4384                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4385                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4386                                 {
4387                                         struct ndr_pull *_ndr_devmode;
4388                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
4389                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
4390                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
4391                                 }
4392                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4393                                 ndr->offset = _relative_save_offset;
4394                         }
4395                         ndr->flags = _flags_save_spoolss_DeviceMode;
4396                 }
4397                 {
4398                         uint32_t _flags_save_string = ndr->flags;
4399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4400                         if (r->text_status) {
4401                                 uint32_t _relative_save_offset;
4402                                 _relative_save_offset = ndr->offset;
4403                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4404                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4405                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4406                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4407                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4408                                 ndr->offset = _relative_save_offset;
4409                         }
4410                         ndr->flags = _flags_save_string;
4411                 }
4412                 {
4413                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4414                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4415                         if (r->secdesc) {
4416                                 uint32_t _relative_save_offset;
4417                                 _relative_save_offset = ndr->offset;
4418                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4419                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4420                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4421                                 {
4422                                         struct ndr_pull *_ndr_secdesc;
4423                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
4424                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4425                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
4426                                 }
4427                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4428                                 ndr->offset = _relative_save_offset;
4429                         }
4430                         ndr->flags = _flags_save_spoolss_security_descriptor;
4431                 }
4432         }
4433         return NDR_ERR_SUCCESS;
4434 }
4435
4436 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4437 {
4438         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4439         ndr->depth++;
4440         ndr_print_uint32(ndr, "job_id", r->job_id);
4441         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4442         ndr->depth++;
4443         if (r->printer_name) {
4444                 ndr_print_string(ndr, "printer_name", r->printer_name);
4445         }
4446         ndr->depth--;
4447         ndr_print_ptr(ndr, "server_name", r->server_name);
4448         ndr->depth++;
4449         if (r->server_name) {
4450                 ndr_print_string(ndr, "server_name", r->server_name);
4451         }
4452         ndr->depth--;
4453         ndr_print_ptr(ndr, "user_name", r->user_name);
4454         ndr->depth++;
4455         if (r->user_name) {
4456                 ndr_print_string(ndr, "user_name", r->user_name);
4457         }
4458         ndr->depth--;
4459         ndr_print_ptr(ndr, "document_name", r->document_name);
4460         ndr->depth++;
4461         if (r->document_name) {
4462                 ndr_print_string(ndr, "document_name", r->document_name);
4463         }
4464         ndr->depth--;
4465         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4466         ndr->depth++;
4467         if (r->notify_name) {
4468                 ndr_print_string(ndr, "notify_name", r->notify_name);
4469         }
4470         ndr->depth--;
4471         ndr_print_ptr(ndr, "data_type", r->data_type);
4472         ndr->depth++;
4473         if (r->data_type) {
4474                 ndr_print_string(ndr, "data_type", r->data_type);
4475         }
4476         ndr->depth--;
4477         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4478         ndr->depth++;
4479         if (r->print_processor) {
4480                 ndr_print_string(ndr, "print_processor", r->print_processor);
4481         }
4482         ndr->depth--;
4483         ndr_print_ptr(ndr, "parameters", r->parameters);
4484         ndr->depth++;
4485         if (r->parameters) {
4486                 ndr_print_string(ndr, "parameters", r->parameters);
4487         }
4488         ndr->depth--;
4489         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4490         ndr->depth++;
4491         if (r->driver_name) {
4492                 ndr_print_string(ndr, "driver_name", r->driver_name);
4493         }
4494         ndr->depth--;
4495         ndr_print_ptr(ndr, "devmode", r->devmode);
4496         ndr->depth++;
4497         if (r->devmode) {
4498                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4499         }
4500         ndr->depth--;
4501         ndr_print_ptr(ndr, "text_status", r->text_status);
4502         ndr->depth++;
4503         if (r->text_status) {
4504                 ndr_print_string(ndr, "text_status", r->text_status);
4505         }
4506         ndr->depth--;
4507         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4508         ndr->depth++;
4509         if (r->secdesc) {
4510                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
4511         }
4512         ndr->depth--;
4513         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4514         ndr_print_uint32(ndr, "priority", r->priority);
4515         ndr_print_uint32(ndr, "position", r->position);
4516         ndr_print_uint32(ndr, "start_time", r->start_time);
4517         ndr_print_uint32(ndr, "until_time", r->until_time);
4518         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4519         ndr_print_uint32(ndr, "size", r->size);
4520         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4521         ndr_print_uint32(ndr, "time", r->time);
4522         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4523         ndr_print_uint32(ndr, "size_high", r->size_high);
4524         ndr->depth--;
4525 }
4526
4527 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
4528 {
4529         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
4530 }
4531
4532 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4533 {
4534         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4535         {
4536                 uint32_t _flags_save_UNION = ndr->flags;
4537                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
4538                 if (ndr_flags & NDR_SCALARS) {
4539                         int level = ndr_push_get_switch_value(ndr, r);
4540                         switch (level) {
4541                                 case 1: {
4542                                         NDR_CHECK(ndr_push_align(ndr, 4));
4543                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4544                                         NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4545                                 break; }
4546
4547                                 case 2: {
4548                                         NDR_CHECK(ndr_push_align(ndr, 4));
4549                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4550                                         NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4551                                 break; }
4552
4553                                 case 3: {
4554                                         NDR_CHECK(ndr_push_align(ndr, 4));
4555                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4556                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4557                                 break; }
4558
4559                                 case 4: {
4560                                         NDR_CHECK(ndr_push_align(ndr, 4));
4561                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4562                                         NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4563                                 break; }
4564
4565                                 default: {
4566                                 break; }
4567
4568                         }
4569                 }
4570                 if (ndr_flags & NDR_BUFFERS) {
4571                         int level = ndr_push_get_switch_value(ndr, r);
4572                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4573                         switch (level) {
4574                                 case 1:
4575                                         NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4576                                 break;
4577
4578                                 case 2:
4579                                         NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4580                                 break;
4581
4582                                 case 3:
4583                                 break;
4584
4585                                 case 4:
4586                                         NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4587                                 break;
4588
4589                                 default:
4590                                 break;
4591
4592                         }
4593                 }
4594                 ndr->flags = _flags_save_UNION;
4595         }
4596         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4597         return NDR_ERR_SUCCESS;
4598 }
4599
4600 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4601 {
4602         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4603         int level;
4604         {
4605                 uint32_t _flags_save_UNION = ndr->flags;
4606                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
4607                 level = ndr_pull_get_switch_value(ndr, r);
4608                 if (ndr_flags & NDR_SCALARS) {
4609                         switch (level) {
4610                                 case 1: {
4611                                         NDR_CHECK(ndr_pull_align(ndr, 4));
4612                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4613                                         NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4614                                 break; }
4615
4616                                 case 2: {
4617                                         NDR_CHECK(ndr_pull_align(ndr, 4));
4618                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4619                                         NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4620                                 break; }
4621
4622                                 case 3: {
4623                                         NDR_CHECK(ndr_pull_align(ndr, 4));
4624                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4625                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4626                                 break; }
4627
4628                                 case 4: {
4629                                         NDR_CHECK(ndr_pull_align(ndr, 4));
4630                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4631                                         NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4632                                 break; }
4633
4634                                 default: {
4635                                 break; }
4636
4637                         }
4638                 }
4639                 if (ndr_flags & NDR_BUFFERS) {
4640                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
4641                         switch (level) {
4642                                 case 1:
4643                                         NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4644                                 break;
4645
4646                                 case 2:
4647                                         NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4648                                 break;
4649
4650                                 case 3:
4651                                 break;
4652
4653                                 case 4:
4654                                         NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4655                                 break;
4656
4657                                 default:
4658                                 break;
4659
4660                         }
4661                 }
4662                 ndr->flags = _flags_save_UNION;
4663         }
4664         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
4665         return NDR_ERR_SUCCESS;
4666 }
4667
4668 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
4669 {
4670         int level;
4671         {
4672                 uint32_t _flags_save_UNION = ndr->flags;
4673                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
4674                 level = ndr_print_get_switch_value(ndr, r);
4675                 ndr_print_union(ndr, name, level, "spoolss_JobInfo");
4676                 switch (level) {
4677                         case 1:
4678                                 ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
4679                         break;
4680
4681                         case 2:
4682                                 ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
4683                         break;
4684
4685                         case 3:
4686                                 ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
4687                         break;
4688
4689                         case 4:
4690                                 ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
4691                         break;
4692
4693                         default:
4694                         break;
4695
4696                 }
4697                 ndr->flags = _flags_save_UNION;
4698         }
4699 }
4700
4701 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
4702 {
4703         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
4704         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
4705 }
4706
4707 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
4708 {
4709         if (ndr_flags & NDR_SCALARS) {
4710                 NDR_CHECK(ndr_push_align(ndr, 4));
4711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4712                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4713                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4714                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4715                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4716                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4717                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4718                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4719                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4720                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4721                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4722                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4723                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4724         }
4725         if (ndr_flags & NDR_BUFFERS) {
4726                 if (r->printer_name) {
4727                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4728                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4729                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4730                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4731                 }
4732                 if (r->server_name) {
4733                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4734                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4735                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4736                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4737                 }
4738                 if (r->user_name) {
4739                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4740                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4741                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4742                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4743                 }
4744                 if (r->document_name) {
4745                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4746                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4748                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4749                 }
4750                 if (r->data_type) {
4751                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4752                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4753                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4754                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4755                 }
4756                 if (r->text_status) {
4757                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4758                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4759                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4760                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4761                 }
4762         }
4763         return NDR_ERR_SUCCESS;
4764 }
4765
4766 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
4767 {
4768         uint32_t _ptr_printer_name;
4769         TALLOC_CTX *_mem_save_printer_name_0;
4770         uint32_t _ptr_server_name;
4771         TALLOC_CTX *_mem_save_server_name_0;
4772         uint32_t _ptr_user_name;
4773         TALLOC_CTX *_mem_save_user_name_0;
4774         uint32_t _ptr_document_name;
4775         TALLOC_CTX *_mem_save_document_name_0;
4776         uint32_t _ptr_data_type;
4777         TALLOC_CTX *_mem_save_data_type_0;
4778         uint32_t _ptr_text_status;
4779         TALLOC_CTX *_mem_save_text_status_0;
4780         if (ndr_flags & NDR_SCALARS) {
4781                 NDR_CHECK(ndr_pull_align(ndr, 4));
4782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4783                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4784                 if (_ptr_printer_name) {
4785                         NDR_PULL_ALLOC(ndr, r->printer_name);
4786                 } else {
4787                         r->printer_name = NULL;
4788                 }
4789                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4790                 if (_ptr_server_name) {
4791                         NDR_PULL_ALLOC(ndr, r->server_name);
4792                 } else {
4793                         r->server_name = NULL;
4794                 }
4795                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4796                 if (_ptr_user_name) {
4797                         NDR_PULL_ALLOC(ndr, r->user_name);
4798                 } else {
4799                         r->user_name = NULL;
4800                 }
4801                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4802                 if (_ptr_document_name) {
4803                         NDR_PULL_ALLOC(ndr, r->document_name);
4804                 } else {
4805                         r->document_name = NULL;
4806                 }
4807                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4808                 if (_ptr_data_type) {
4809                         NDR_PULL_ALLOC(ndr, r->data_type);
4810                 } else {
4811                         r->data_type = NULL;
4812                 }
4813                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4814                 if (_ptr_text_status) {
4815                         NDR_PULL_ALLOC(ndr, r->text_status);
4816                 } else {
4817                         r->text_status = NULL;
4818                 }
4819                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4821                 if (r->priority > 99) {
4822                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4823                 }
4824                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4826                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4827                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4828         }
4829         if (ndr_flags & NDR_BUFFERS) {
4830                 if (r->printer_name) {
4831                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4832                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4833                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
4834                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
4835                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
4836                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
4837                         }
4838                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
4839                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
4840                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4841                 }
4842                 if (r->server_name) {
4843                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4844                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4845                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
4846                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
4847                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
4848                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
4849                         }
4850                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
4851                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
4852                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4853                 }
4854                 if (r->user_name) {
4855                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4856                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4857                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4858                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4859                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4860                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
4861                         }
4862                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4863                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4864                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4865                 }
4866                 if (r->document_name) {
4867                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4868                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4869                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
4870                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
4871                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
4872                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
4873                         }
4874                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
4875                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
4876                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4877                 }
4878                 if (r->data_type) {
4879                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4880                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4881                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
4882                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
4883                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
4884                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
4885                         }
4886                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
4887                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
4888                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4889                 }
4890                 if (r->text_status) {
4891                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4892                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4893                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
4894                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
4895                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
4896                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
4897                         }
4898                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
4899                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
4900                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4901                 }
4902         }
4903         return NDR_ERR_SUCCESS;
4904 }
4905
4906 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
4907 {
4908         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
4909         ndr->depth++;
4910         ndr_print_uint32(ndr, "job_id", r->job_id);
4911         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4912         ndr->depth++;
4913         if (r->printer_name) {
4914                 ndr_print_string(ndr, "printer_name", r->printer_name);
4915         }
4916         ndr->depth--;
4917         ndr_print_ptr(ndr, "server_name", r->server_name);
4918         ndr->depth++;
4919         if (r->server_name) {
4920                 ndr_print_string(ndr, "server_name", r->server_name);
4921         }
4922         ndr->depth--;
4923         ndr_print_ptr(ndr, "user_name", r->user_name);
4924         ndr->depth++;
4925         if (r->user_name) {
4926                 ndr_print_string(ndr, "user_name", r->user_name);
4927         }
4928         ndr->depth--;
4929         ndr_print_ptr(ndr, "document_name", r->document_name);
4930         ndr->depth++;
4931         if (r->document_name) {
4932                 ndr_print_string(ndr, "document_name", r->document_name);
4933         }
4934         ndr->depth--;
4935         ndr_print_ptr(ndr, "data_type", r->data_type);
4936         ndr->depth++;
4937         if (r->data_type) {
4938                 ndr_print_string(ndr, "data_type", r->data_type);
4939         }
4940         ndr->depth--;
4941         ndr_print_ptr(ndr, "text_status", r->text_status);
4942         ndr->depth++;
4943         if (r->text_status) {
4944                 ndr_print_string(ndr, "text_status", r->text_status);
4945         }
4946         ndr->depth--;
4947         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4948         ndr_print_uint32(ndr, "priority", r->priority);
4949         ndr_print_uint32(ndr, "position", r->position);
4950         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4951         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4952         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4953         ndr->depth--;
4954 }
4955
4956 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
4957 {
4958         if (ndr_flags & NDR_SCALARS) {
4959                 NDR_CHECK(ndr_push_align(ndr, 4));
4960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4961                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4962                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4963                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4964                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4965                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
4966                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4967                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
4968                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
4969                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4970                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
4971                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4972                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
4973                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4974                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4975                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4976                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4977                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4980                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4983         }
4984         if (ndr_flags & NDR_BUFFERS) {
4985                 if (r->printer_name) {
4986                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4987                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4988                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4989                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4990                 }
4991                 if (r->server_name) {
4992                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4993                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4994                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4995                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4996                 }
4997                 if (r->user_name) {
4998                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4999                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5000                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5001                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5002                 }
5003                 if (r->document_name) {
5004                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5005                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5006                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5007                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5008                 }
5009                 if (r->notify_name) {
5010                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5011                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5012                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5013                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5014                 }
5015                 if (r->data_type) {
5016                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5017                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5018                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5019                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5020                 }
5021                 if (r->print_processor) {
5022                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5023                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5024                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5025                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5026                 }
5027                 if (r->parameters) {
5028                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5029                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5030                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5031                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5032                 }
5033                 if (r->driver_name) {
5034                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5035                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5036                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5037                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5038                 }
5039                 if (r->text_status) {
5040                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5041                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5042                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5043                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5044                 }
5045         }
5046         return NDR_ERR_SUCCESS;
5047 }
5048
5049 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
5050 {
5051         uint32_t _ptr_printer_name;
5052         TALLOC_CTX *_mem_save_printer_name_0;
5053         uint32_t _ptr_server_name;
5054         TALLOC_CTX *_mem_save_server_name_0;
5055         uint32_t _ptr_user_name;
5056         TALLOC_CTX *_mem_save_user_name_0;
5057         uint32_t _ptr_document_name;
5058         TALLOC_CTX *_mem_save_document_name_0;
5059         uint32_t _ptr_notify_name;
5060         TALLOC_CTX *_mem_save_notify_name_0;
5061         uint32_t _ptr_data_type;
5062         TALLOC_CTX *_mem_save_data_type_0;
5063         uint32_t _ptr_print_processor;
5064         TALLOC_CTX *_mem_save_print_processor_0;
5065         uint32_t _ptr_parameters;
5066         TALLOC_CTX *_mem_save_parameters_0;
5067         uint32_t _ptr_driver_name;
5068         TALLOC_CTX *_mem_save_driver_name_0;
5069         uint32_t _ptr_text_status;
5070         TALLOC_CTX *_mem_save_text_status_0;
5071         if (ndr_flags & NDR_SCALARS) {
5072                 NDR_CHECK(ndr_pull_align(ndr, 4));
5073                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5074                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5075                 if (_ptr_printer_name) {
5076                         NDR_PULL_ALLOC(ndr, r->printer_name);
5077                 } else {
5078                         r->printer_name = NULL;
5079                 }
5080                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5081                 if (_ptr_server_name) {
5082                         NDR_PULL_ALLOC(ndr, r->server_name);
5083                 } else {
5084                         r->server_name = NULL;
5085                 }
5086                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5087                 if (_ptr_user_name) {
5088                         NDR_PULL_ALLOC(ndr, r->user_name);
5089                 } else {
5090                         r->user_name = NULL;
5091                 }
5092                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5093                 if (_ptr_document_name) {
5094                         NDR_PULL_ALLOC(ndr, r->document_name);
5095                 } else {
5096                         r->document_name = NULL;
5097                 }
5098                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5099                 if (_ptr_notify_name) {
5100                         NDR_PULL_ALLOC(ndr, r->notify_name);
5101                 } else {
5102                         r->notify_name = NULL;
5103                 }
5104                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5105                 if (_ptr_data_type) {
5106                         NDR_PULL_ALLOC(ndr, r->data_type);
5107                 } else {
5108                         r->data_type = NULL;
5109                 }
5110                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5111                 if (_ptr_print_processor) {
5112                         NDR_PULL_ALLOC(ndr, r->print_processor);
5113                 } else {
5114                         r->print_processor = NULL;
5115                 }
5116                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5117                 if (_ptr_parameters) {
5118                         NDR_PULL_ALLOC(ndr, r->parameters);
5119                 } else {
5120                         r->parameters = NULL;
5121                 }
5122                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5123                 if (_ptr_driver_name) {
5124                         NDR_PULL_ALLOC(ndr, r->driver_name);
5125                 } else {
5126                         r->driver_name = NULL;
5127                 }
5128                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5130                 if (_ptr_text_status) {
5131                         NDR_PULL_ALLOC(ndr, r->text_status);
5132                 } else {
5133                         r->text_status = NULL;
5134                 }
5135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5136                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5137                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5138                 if (r->priority > 99) {
5139                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5140                 }
5141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5146                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5147                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5148                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5149         }
5150         if (ndr_flags & NDR_BUFFERS) {
5151                 if (r->printer_name) {
5152                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5153                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5154                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5155                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5156                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5157                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5158                         }
5159                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5160                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5161                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5162                 }
5163                 if (r->server_name) {
5164                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5165                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5166                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5167                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5168                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5169                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5170                         }
5171                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5172                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5173                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5174                 }
5175                 if (r->user_name) {
5176                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5177                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5178                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5179                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5180                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5181                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
5182                         }
5183                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5184                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5185                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5186                 }
5187                 if (r->document_name) {
5188                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5189                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5190                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5191                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5192                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5193                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
5194                         }
5195                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5196                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5197                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5198                 }
5199                 if (r->notify_name) {
5200                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5201                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5202                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5203                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5204                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5205                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->notify_name), ndr_get_array_length(ndr, &r->notify_name));
5206                         }
5207                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5208                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5209                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5210                 }
5211                 if (r->data_type) {
5212                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5213                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5214                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5215                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5216                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5217                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
5218                         }
5219                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5220                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5221                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5222                 }
5223                 if (r->print_processor) {
5224                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5225                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5226                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5227                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5228                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5229                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
5230                         }
5231                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5232                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5233                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5234                 }
5235                 if (r->parameters) {
5236                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5237                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5238                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5239                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5240                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5241                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
5242                         }
5243                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5244                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5245                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5246                 }
5247                 if (r->driver_name) {
5248                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5249                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5250                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5251                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5252                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5253                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5254                         }
5255                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5256                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5257                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5258                 }
5259                 if (r->text_status) {
5260                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5261                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5262                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5263                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5264                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5265                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
5266                         }
5267                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5268                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5269                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5270                 }
5271         }
5272         return NDR_ERR_SUCCESS;
5273 }
5274
5275 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
5276 {
5277         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
5278         ndr->depth++;
5279         ndr_print_uint32(ndr, "job_id", r->job_id);
5280         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5281         ndr->depth++;
5282         if (r->printer_name) {
5283                 ndr_print_string(ndr, "printer_name", r->printer_name);
5284         }
5285         ndr->depth--;
5286         ndr_print_ptr(ndr, "server_name", r->server_name);
5287         ndr->depth++;
5288         if (r->server_name) {
5289                 ndr_print_string(ndr, "server_name", r->server_name);
5290         }
5291         ndr->depth--;
5292         ndr_print_ptr(ndr, "user_name", r->user_name);
5293         ndr->depth++;
5294         if (r->user_name) {
5295                 ndr_print_string(ndr, "user_name", r->user_name);
5296         }
5297         ndr->depth--;
5298         ndr_print_ptr(ndr, "document_name", r->document_name);
5299         ndr->depth++;
5300         if (r->document_name) {
5301                 ndr_print_string(ndr, "document_name", r->document_name);
5302         }
5303         ndr->depth--;
5304         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5305         ndr->depth++;
5306         if (r->notify_name) {
5307                 ndr_print_string(ndr, "notify_name", r->notify_name);
5308         }
5309         ndr->depth--;
5310         ndr_print_ptr(ndr, "data_type", r->data_type);
5311         ndr->depth++;
5312         if (r->data_type) {
5313                 ndr_print_string(ndr, "data_type", r->data_type);
5314         }
5315         ndr->depth--;
5316         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5317         ndr->depth++;
5318         if (r->print_processor) {
5319                 ndr_print_string(ndr, "print_processor", r->print_processor);
5320         }
5321         ndr->depth--;
5322         ndr_print_ptr(ndr, "parameters", r->parameters);
5323         ndr->depth++;
5324         if (r->parameters) {
5325                 ndr_print_string(ndr, "parameters", r->parameters);
5326         }
5327         ndr->depth--;
5328         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5329         ndr->depth++;
5330         if (r->driver_name) {
5331                 ndr_print_string(ndr, "driver_name", r->driver_name);
5332         }
5333         ndr->depth--;
5334         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5335         ndr_print_ptr(ndr, "text_status", r->text_status);
5336         ndr->depth++;
5337         if (r->text_status) {
5338                 ndr_print_string(ndr, "text_status", r->text_status);
5339         }
5340         ndr->depth--;
5341         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5342         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5343         ndr_print_uint32(ndr, "priority", r->priority);
5344         ndr_print_uint32(ndr, "position", r->position);
5345         ndr_print_uint32(ndr, "start_time", r->start_time);
5346         ndr_print_uint32(ndr, "until_time", r->until_time);
5347         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5348         ndr_print_uint32(ndr, "size", r->size);
5349         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5350         ndr_print_uint32(ndr, "time", r->time);
5351         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5352         ndr->depth--;
5353 }
5354
5355 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
5356 {
5357         if (ndr_flags & NDR_SCALARS) {
5358                 NDR_CHECK(ndr_push_align(ndr, 4));
5359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5360                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5362                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5363                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5364                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5365                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5366                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5367                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5368                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5370                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5371                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5372                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5373                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5374                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5376                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5378                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5379                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5380                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5381                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5382                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5383         }
5384         if (ndr_flags & NDR_BUFFERS) {
5385                 if (r->printer_name) {
5386                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5387                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5388                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5389                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5390                 }
5391                 if (r->server_name) {
5392                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5393                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5394                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5395                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5396                 }
5397                 if (r->user_name) {
5398                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5399                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5400                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5401                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5402                 }
5403                 if (r->document_name) {
5404                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5405                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5406                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5407                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5408                 }
5409                 if (r->notify_name) {
5410                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5411                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5412                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5413                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5414                 }
5415                 if (r->data_type) {
5416                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5417                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5418                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5419                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5420                 }
5421                 if (r->print_processor) {
5422                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5423                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5424                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5425                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5426                 }
5427                 if (r->parameters) {
5428                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5429                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5430                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5431                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5432                 }
5433                 if (r->driver_name) {
5434                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5435                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5437                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5438                 }
5439                 if (r->text_status) {
5440                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5441                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5443                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5444                 }
5445         }
5446         return NDR_ERR_SUCCESS;
5447 }
5448
5449 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5450 {
5451         uint32_t _ptr_printer_name;
5452         TALLOC_CTX *_mem_save_printer_name_0;
5453         uint32_t _ptr_server_name;
5454         TALLOC_CTX *_mem_save_server_name_0;
5455         uint32_t _ptr_user_name;
5456         TALLOC_CTX *_mem_save_user_name_0;
5457         uint32_t _ptr_document_name;
5458         TALLOC_CTX *_mem_save_document_name_0;
5459         uint32_t _ptr_notify_name;
5460         TALLOC_CTX *_mem_save_notify_name_0;
5461         uint32_t _ptr_data_type;
5462         TALLOC_CTX *_mem_save_data_type_0;
5463         uint32_t _ptr_print_processor;
5464         TALLOC_CTX *_mem_save_print_processor_0;
5465         uint32_t _ptr_parameters;
5466         TALLOC_CTX *_mem_save_parameters_0;
5467         uint32_t _ptr_driver_name;
5468         TALLOC_CTX *_mem_save_driver_name_0;
5469         uint32_t _ptr_text_status;
5470         TALLOC_CTX *_mem_save_text_status_0;
5471         if (ndr_flags & NDR_SCALARS) {
5472                 NDR_CHECK(ndr_pull_align(ndr, 4));
5473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5474                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5475                 if (_ptr_printer_name) {
5476                         NDR_PULL_ALLOC(ndr, r->printer_name);
5477                 } else {
5478                         r->printer_name = NULL;
5479                 }
5480                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5481                 if (_ptr_server_name) {
5482                         NDR_PULL_ALLOC(ndr, r->server_name);
5483                 } else {
5484                         r->server_name = NULL;
5485                 }
5486                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5487                 if (_ptr_user_name) {
5488                         NDR_PULL_ALLOC(ndr, r->user_name);
5489                 } else {
5490                         r->user_name = NULL;
5491                 }
5492                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5493                 if (_ptr_document_name) {
5494                         NDR_PULL_ALLOC(ndr, r->document_name);
5495                 } else {
5496                         r->document_name = NULL;
5497                 }
5498                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5499                 if (_ptr_notify_name) {
5500                         NDR_PULL_ALLOC(ndr, r->notify_name);
5501                 } else {
5502                         r->notify_name = NULL;
5503                 }
5504                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5505                 if (_ptr_data_type) {
5506                         NDR_PULL_ALLOC(ndr, r->data_type);
5507                 } else {
5508                         r->data_type = NULL;
5509                 }
5510                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5511                 if (_ptr_print_processor) {
5512                         NDR_PULL_ALLOC(ndr, r->print_processor);
5513                 } else {
5514                         r->print_processor = NULL;
5515                 }
5516                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5517                 if (_ptr_parameters) {
5518                         NDR_PULL_ALLOC(ndr, r->parameters);
5519                 } else {
5520                         r->parameters = NULL;
5521                 }
5522                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5523                 if (_ptr_driver_name) {
5524                         NDR_PULL_ALLOC(ndr, r->driver_name);
5525                 } else {
5526                         r->driver_name = NULL;
5527                 }
5528                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5529                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5530                 if (_ptr_text_status) {
5531                         NDR_PULL_ALLOC(ndr, r->text_status);
5532                 } else {
5533                         r->text_status = NULL;
5534                 }
5535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5536                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5537                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5538                 if (r->priority > 99) {
5539                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5540                 }
5541                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5543                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5544                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5546                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5547                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5550         }
5551         if (ndr_flags & NDR_BUFFERS) {
5552                 if (r->printer_name) {
5553                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5554                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5555                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5556                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5557                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5558                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5559                         }
5560                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5561                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5562                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5563                 }
5564                 if (r->server_name) {
5565                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5566                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5567                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5568                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5569                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5570                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5571                         }
5572                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5573                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5574                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5575                 }
5576                 if (r->user_name) {
5577                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5578                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5579                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5580                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5581                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5582                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
5583                         }
5584                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5585                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5586                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5587                 }
5588                 if (r->document_name) {
5589                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5590                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5591                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5592                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5593                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5594                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
5595                         }
5596                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5597                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5598                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5599                 }
5600                 if (r->notify_name) {
5601                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5602                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5603                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5604                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5605                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5606                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->notify_name), ndr_get_array_length(ndr, &r->notify_name));
5607                         }
5608                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5609                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5610                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5611                 }
5612                 if (r->data_type) {
5613                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5614                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5615                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5616                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5617                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5618                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
5619                         }
5620                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5621                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5622                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5623                 }
5624                 if (r->print_processor) {
5625                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5626                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5627                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5628                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5629                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5630                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
5631                         }
5632                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5633                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5634                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5635                 }
5636                 if (r->parameters) {
5637                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5638                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5639                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5640                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5641                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5642                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
5643                         }
5644                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5645                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5646                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5647                 }
5648                 if (r->driver_name) {
5649                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5650                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5651                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5652                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5653                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5654                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5655                         }
5656                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5657                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5658                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5659                 }
5660                 if (r->text_status) {
5661                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5662                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5663                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5664                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5665                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5666                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
5667                         }
5668                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5669                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5670                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5671                 }
5672         }
5673         return NDR_ERR_SUCCESS;
5674 }
5675
5676 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
5677 {
5678         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
5679         ndr->depth++;
5680         ndr_print_uint32(ndr, "job_id", r->job_id);
5681         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5682         ndr->depth++;
5683         if (r->printer_name) {
5684                 ndr_print_string(ndr, "printer_name", r->printer_name);
5685         }
5686         ndr->depth--;
5687         ndr_print_ptr(ndr, "server_name", r->server_name);
5688         ndr->depth++;
5689         if (r->server_name) {
5690                 ndr_print_string(ndr, "server_name", r->server_name);
5691         }
5692         ndr->depth--;
5693         ndr_print_ptr(ndr, "user_name", r->user_name);
5694         ndr->depth++;
5695         if (r->user_name) {
5696                 ndr_print_string(ndr, "user_name", r->user_name);
5697         }
5698         ndr->depth--;
5699         ndr_print_ptr(ndr, "document_name", r->document_name);
5700         ndr->depth++;
5701         if (r->document_name) {
5702                 ndr_print_string(ndr, "document_name", r->document_name);
5703         }
5704         ndr->depth--;
5705         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5706         ndr->depth++;
5707         if (r->notify_name) {
5708                 ndr_print_string(ndr, "notify_name", r->notify_name);
5709         }
5710         ndr->depth--;
5711         ndr_print_ptr(ndr, "data_type", r->data_type);
5712         ndr->depth++;
5713         if (r->data_type) {
5714                 ndr_print_string(ndr, "data_type", r->data_type);
5715         }
5716         ndr->depth--;
5717         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5718         ndr->depth++;
5719         if (r->print_processor) {
5720                 ndr_print_string(ndr, "print_processor", r->print_processor);
5721         }
5722         ndr->depth--;
5723         ndr_print_ptr(ndr, "parameters", r->parameters);
5724         ndr->depth++;
5725         if (r->parameters) {
5726                 ndr_print_string(ndr, "parameters", r->parameters);
5727         }
5728         ndr->depth--;
5729         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5730         ndr->depth++;
5731         if (r->driver_name) {
5732                 ndr_print_string(ndr, "driver_name", r->driver_name);
5733         }
5734         ndr->depth--;
5735         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5736         ndr_print_ptr(ndr, "text_status", r->text_status);
5737         ndr->depth++;
5738         if (r->text_status) {
5739                 ndr_print_string(ndr, "text_status", r->text_status);
5740         }
5741         ndr->depth--;
5742         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5743         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5744         ndr_print_uint32(ndr, "priority", r->priority);
5745         ndr_print_uint32(ndr, "position", r->position);
5746         ndr_print_uint32(ndr, "start_time", r->start_time);
5747         ndr_print_uint32(ndr, "until_time", r->until_time);
5748         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5749         ndr_print_uint32(ndr, "size", r->size);
5750         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5751         ndr_print_uint32(ndr, "time", r->time);
5752         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5753         ndr_print_uint32(ndr, "size_high", r->size_high);
5754         ndr->depth--;
5755 }
5756
5757 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
5758 {
5759         if (ndr_flags & NDR_SCALARS) {
5760                 int level = ndr_push_get_switch_value(ndr, r);
5761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5762                 switch (level) {
5763                         case 1: {
5764                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
5765                         break; }
5766
5767                         case 2: {
5768                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
5769                         break; }
5770
5771                         case 3: {
5772                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
5773                         break; }
5774
5775                         case 4: {
5776                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
5777                         break; }
5778
5779                         default: {
5780                         break; }
5781
5782                 }
5783         }
5784         if (ndr_flags & NDR_BUFFERS) {
5785                 int level = ndr_push_get_switch_value(ndr, r);
5786                 switch (level) {
5787                         case 1:
5788                                 if (r->info1) {
5789                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5790                                 }
5791                         break;
5792
5793                         case 2:
5794                                 if (r->info2) {
5795                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5796                                 }
5797                         break;
5798
5799                         case 3:
5800                                 if (r->info3) {
5801                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5802                                 }
5803                         break;
5804
5805                         case 4:
5806                                 if (r->info4) {
5807                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5808                                 }
5809                         break;
5810
5811                         default:
5812                         break;
5813
5814                 }
5815         }
5816         return NDR_ERR_SUCCESS;
5817 }
5818
5819 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
5820 {
5821         int level;
5822         uint32_t _level;
5823         TALLOC_CTX *_mem_save_info1_0;
5824         TALLOC_CTX *_mem_save_info2_0;
5825         TALLOC_CTX *_mem_save_info3_0;
5826         TALLOC_CTX *_mem_save_info4_0;
5827         level = ndr_pull_get_switch_value(ndr, r);
5828         if (ndr_flags & NDR_SCALARS) {
5829                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5830                 if (_level != level) {
5831                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5832                 }
5833                 switch (level) {
5834                         case 1: {
5835                                 uint32_t _ptr_info1;
5836                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
5837                                 if (_ptr_info1) {
5838                                         NDR_PULL_ALLOC(ndr, r->info1);
5839                                 } else {
5840                                         r->info1 = NULL;
5841                                 }
5842                         break; }
5843
5844                         case 2: {
5845                                 uint32_t _ptr_info2;
5846                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
5847                                 if (_ptr_info2) {
5848                                         NDR_PULL_ALLOC(ndr, r->info2);
5849                                 } else {
5850                                         r->info2 = NULL;
5851                                 }
5852                         break; }
5853
5854                         case 3: {
5855                                 uint32_t _ptr_info3;
5856                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
5857                                 if (_ptr_info3) {
5858                                         NDR_PULL_ALLOC(ndr, r->info3);
5859                                 } else {
5860                                         r->info3 = NULL;
5861                                 }
5862                         break; }
5863
5864                         case 4: {
5865                                 uint32_t _ptr_info4;
5866                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
5867                                 if (_ptr_info4) {
5868                                         NDR_PULL_ALLOC(ndr, r->info4);
5869                                 } else {
5870                                         r->info4 = NULL;
5871                                 }
5872                         break; }
5873
5874                         default: {
5875                         break; }
5876
5877                 }
5878         }
5879         if (ndr_flags & NDR_BUFFERS) {
5880                 switch (level) {
5881                         case 1:
5882                                 if (r->info1) {
5883                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5884                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
5885                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5886                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
5887                                 }
5888                         break;
5889
5890                         case 2:
5891                                 if (r->info2) {
5892                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5893                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
5894                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5895                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
5896                                 }
5897                         break;
5898
5899                         case 3:
5900                                 if (r->info3) {
5901                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
5902                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
5903                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5904                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
5905                                 }
5906                         break;
5907
5908                         case 4:
5909                                 if (r->info4) {
5910                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
5911                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
5912                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5913                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
5914                                 }
5915                         break;
5916
5917                         default:
5918                         break;
5919
5920                 }
5921         }
5922         return NDR_ERR_SUCCESS;
5923 }
5924
5925 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
5926 {
5927         int level;
5928         level = ndr_print_get_switch_value(ndr, r);
5929         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
5930         switch (level) {
5931                 case 1:
5932                         ndr_print_ptr(ndr, "info1", r->info1);
5933                         ndr->depth++;
5934                         if (r->info1) {
5935                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
5936                         }
5937                         ndr->depth--;
5938                 break;
5939
5940                 case 2:
5941                         ndr_print_ptr(ndr, "info2", r->info2);
5942                         ndr->depth++;
5943                         if (r->info2) {
5944                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
5945                         }
5946                         ndr->depth--;
5947                 break;
5948
5949                 case 3:
5950                         ndr_print_ptr(ndr, "info3", r->info3);
5951                         ndr->depth++;
5952                         if (r->info3) {
5953                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
5954                         }
5955                         ndr->depth--;
5956                 break;
5957
5958                 case 4:
5959                         ndr_print_ptr(ndr, "info4", r->info4);
5960                         ndr->depth++;
5961                         if (r->info4) {
5962                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
5963                         }
5964                         ndr->depth--;
5965                 break;
5966
5967                 default:
5968                 break;
5969
5970         }
5971 }
5972
5973 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
5974 {
5975         if (ndr_flags & NDR_SCALARS) {
5976                 NDR_CHECK(ndr_push_align(ndr, 4));
5977                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
5978                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
5979                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5980         }
5981         if (ndr_flags & NDR_BUFFERS) {
5982                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5983         }
5984         return NDR_ERR_SUCCESS;
5985 }
5986
5987 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
5988 {
5989         if (ndr_flags & NDR_SCALARS) {
5990                 NDR_CHECK(ndr_pull_align(ndr, 4));
5991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
5992                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
5993                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5994         }
5995         if (ndr_flags & NDR_BUFFERS) {
5996                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5997         }
5998         return NDR_ERR_SUCCESS;
5999 }
6000
6001 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
6002 {
6003         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
6004         ndr->depth++;
6005         ndr_print_uint32(ndr, "level", r->level);
6006         ndr_print_set_switch_value(ndr, &r->info, r->level);
6007         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
6008         ndr->depth--;
6009 }
6010
6011 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
6012 {
6013         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
6014         return NDR_ERR_SUCCESS;
6015 }
6016
6017 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
6018 {
6019         uint32_t v;
6020         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
6021         *r = v;
6022         return NDR_ERR_SUCCESS;
6023 }
6024
6025 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
6026 {
6027         const char *val = NULL;
6028
6029         switch (r) {
6030                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
6031                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
6032                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
6033                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
6034                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
6035                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
6036                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
6037                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
6038                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
6039         }
6040         ndr_print_enum(ndr, name, "ENUM", val, r);
6041 }
6042
6043 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
6044 {
6045         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
6046         return NDR_ERR_SUCCESS;
6047 }
6048
6049 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
6050 {
6051         uint32_t v;
6052         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
6053         *r = v;
6054         return NDR_ERR_SUCCESS;
6055 }
6056
6057 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
6058 {
6059         const char *val = NULL;
6060
6061         switch (r) {
6062                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
6063                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
6064                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
6065                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
6066                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
6067         }
6068         ndr_print_enum(ndr, name, "ENUM", val, r);
6069 }
6070
6071 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
6072 {
6073         if (ndr_flags & NDR_SCALARS) {
6074                 NDR_CHECK(ndr_push_align(ndr, 4));
6075                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6076                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
6079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
6080                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
6082                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
6083                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
6084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
6085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
6086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
6087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
6088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
6089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
6090                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
6091                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
6092                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
6093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
6094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
6095                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
6096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
6097                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
6098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
6099                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
6100                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
6101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
6102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
6103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
6104         }
6105         if (ndr_flags & NDR_BUFFERS) {
6106                 if (r->servername) {
6107                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6108                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6109                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6110                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6111                 }
6112                 if (r->printername) {
6113                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6114                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6115                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6116                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6117                 }
6118         }
6119         return NDR_ERR_SUCCESS;
6120 }
6121
6122 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
6123 {
6124         uint32_t _ptr_servername;
6125         TALLOC_CTX *_mem_save_servername_0;
6126         uint32_t _ptr_printername;
6127         TALLOC_CTX *_mem_save_printername_0;
6128         if (ndr_flags & NDR_SCALARS) {
6129                 NDR_CHECK(ndr_pull_align(ndr, 4));
6130                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6131                 if (_ptr_servername) {
6132                         NDR_PULL_ALLOC(ndr, r->servername);
6133                 } else {
6134                         r->servername = NULL;
6135                 }
6136                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6137                 if (_ptr_printername) {
6138                         NDR_PULL_ALLOC(ndr, r->printername);
6139                 } else {
6140                         r->printername = NULL;
6141                 }
6142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
6144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
6145                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6146                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
6147                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
6148                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
6149                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
6150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
6151                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
6152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
6153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
6154                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
6155                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
6156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
6157                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
6158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
6159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
6160                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
6161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
6162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
6163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
6164                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
6165                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
6166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
6167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
6168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
6169         }
6170         if (ndr_flags & NDR_BUFFERS) {
6171                 if (r->servername) {
6172                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6173                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6174                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6175                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6176                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6177                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
6178                         }
6179                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6180                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6181                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6182                 }
6183                 if (r->printername) {
6184                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6185                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6186                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6187                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6188                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6189                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
6190                         }
6191                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6192                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6193                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6194                 }
6195         }
6196         return NDR_ERR_SUCCESS;
6197 }
6198
6199 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
6200 {
6201         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
6202         ndr->depth++;
6203         ndr_print_ptr(ndr, "servername", r->servername);
6204         ndr->depth++;
6205         if (r->servername) {
6206                 ndr_print_string(ndr, "servername", r->servername);
6207         }
6208         ndr->depth--;
6209         ndr_print_ptr(ndr, "printername", r->printername);
6210         ndr->depth++;
6211         if (r->printername) {
6212                 ndr_print_string(ndr, "printername", r->printername);
6213         }
6214         ndr->depth--;
6215         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6216         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
6217         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
6218         ndr_print_spoolss_Time(ndr, "time", &r->time);
6219         ndr_print_uint32(ndr, "global_counter", r->global_counter);
6220         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6221         ndr_print_uint32(ndr, "version", r->version);
6222         ndr_print_uint32(ndr, "free_build", r->free_build);
6223         ndr_print_uint32(ndr, "spooling", r->spooling);
6224         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
6225         ndr_print_uint32(ndr, "session_counter", r->session_counter);
6226         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
6227         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
6228         ndr_print_uint32(ndr, "job_error", r->job_error);
6229         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
6230         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
6231         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
6232         ndr_print_uint32(ndr, "change_id", r->change_id);
6233         ndr_print_WERROR(ndr, "last_error", r->last_error);
6234         ndr_print_uint32(ndr, "status", r->status);
6235         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
6236         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
6237         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
6238         ndr_print_uint16(ndr, "processor_level", r->processor_level);
6239         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
6240         ndr_print_uint32(ndr, "reserved2", r->reserved2);
6241         ndr_print_uint32(ndr, "reserved3", r->reserved3);
6242         ndr->depth--;
6243 }
6244
6245 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
6246 {
6247         if (ndr_flags & NDR_SCALARS) {
6248                 NDR_CHECK(ndr_push_align(ndr, 4));
6249                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
6250                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
6251                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
6252                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6253         }
6254         if (ndr_flags & NDR_BUFFERS) {
6255                 if (r->description) {
6256                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6257                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6258                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6259                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6260                 }
6261                 if (r->name) {
6262                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6263                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6264                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6265                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6266                 }
6267                 if (r->comment) {
6268                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6269                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6270                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6271                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6272                 }
6273         }
6274         return NDR_ERR_SUCCESS;
6275 }
6276
6277 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
6278 {
6279         uint32_t _ptr_description;
6280         TALLOC_CTX *_mem_save_description_0;
6281         uint32_t _ptr_name;
6282         TALLOC_CTX *_mem_save_name_0;
6283         uint32_t _ptr_comment;
6284         TALLOC_CTX *_mem_save_comment_0;
6285         if (ndr_flags & NDR_SCALARS) {
6286                 NDR_CHECK(ndr_pull_align(ndr, 4));
6287                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
6288                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
6289                 if (_ptr_description) {
6290                         NDR_PULL_ALLOC(ndr, r->description);
6291                 } else {
6292                         r->description = NULL;
6293                 }
6294                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
6295                 if (_ptr_name) {
6296                         NDR_PULL_ALLOC(ndr, r->name);
6297                 } else {
6298                         r->name = NULL;
6299                 }
6300                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6301                 if (_ptr_comment) {
6302                         NDR_PULL_ALLOC(ndr, r->comment);
6303                 } else {
6304                         r->comment = NULL;
6305                 }
6306         }
6307         if (ndr_flags & NDR_BUFFERS) {
6308                 if (r->description) {
6309                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
6310                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
6311                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
6312                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
6313                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
6314                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->description), ndr_get_array_length(ndr, &r->description));
6315                         }
6316                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
6317                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
6318                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
6319                 }
6320                 if (r->name) {
6321                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6322                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
6323                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
6324                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
6325                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
6326                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
6327                         }
6328                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
6329                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
6330                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6331                 }
6332                 if (r->comment) {
6333                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6334                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6335                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6336                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6337                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6338                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
6339                         }
6340                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6341                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6342                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6343                 }
6344         }
6345         return NDR_ERR_SUCCESS;
6346 }
6347
6348 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
6349 {
6350         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
6351         ndr->depth++;
6352         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
6353         ndr_print_ptr(ndr, "description", r->description);
6354         ndr->depth++;
6355         if (r->description) {
6356                 ndr_print_string(ndr, "description", r->description);
6357         }
6358         ndr->depth--;
6359         ndr_print_ptr(ndr, "name", r->name);
6360         ndr->depth++;
6361         if (r->name) {
6362                 ndr_print_string(ndr, "name", r->name);
6363         }
6364         ndr->depth--;
6365         ndr_print_ptr(ndr, "comment", r->comment);
6366         ndr->depth++;
6367         if (r->comment) {
6368                 ndr_print_string(ndr, "comment", r->comment);
6369         }
6370         ndr->depth--;
6371         ndr->depth--;
6372 }
6373
6374 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
6375 {
6376         if (ndr_flags & NDR_SCALARS) {
6377                 NDR_CHECK(ndr_push_align(ndr, 4));
6378                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6379                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6380                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6381                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6382                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6383                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6384                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6385                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
6386                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6387                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6388                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6389                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6390                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
6391                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6396                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6399         }
6400         if (ndr_flags & NDR_BUFFERS) {
6401                 if (r->servername) {
6402                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6403                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6404                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6405                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6406                 }
6407                 if (r->printername) {
6408                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6410                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6411                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6412                 }
6413                 if (r->sharename) {
6414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6415                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6416                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6417                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6418                 }
6419                 if (r->portname) {
6420                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6421                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6422                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6423                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6424                 }
6425                 if (r->drivername) {
6426                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6427                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6428                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6429                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6430                 }
6431                 if (r->comment) {
6432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6433                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6434                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6435                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6436                 }
6437                 if (r->location) {
6438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6439                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6440                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6441                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6442                 }
6443                 if (r->devmode) {
6444                         {
6445                                 struct ndr_push *_ndr_devmode;
6446                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6447                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6448                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
6449                         }
6450                 }
6451                 if (r->sepfile) {
6452                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6453                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6455                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6456                 }
6457                 if (r->printprocessor) {
6458                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6459                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6460                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6461                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6462                 }
6463                 if (r->datatype) {
6464                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6465                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6466                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6467                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6468                 }
6469                 if (r->parameters) {
6470                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6471                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6472                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6473                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6474                 }
6475                 if (r->secdesc) {
6476                         {
6477                                 struct ndr_push *_ndr_secdesc;
6478                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6479                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6480                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6481                         }
6482                 }
6483         }
6484         return NDR_ERR_SUCCESS;
6485 }
6486
6487 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6488 {
6489         uint32_t _ptr_servername;
6490         TALLOC_CTX *_mem_save_servername_0;
6491         uint32_t _ptr_printername;
6492         TALLOC_CTX *_mem_save_printername_0;
6493         uint32_t _ptr_sharename;
6494         TALLOC_CTX *_mem_save_sharename_0;
6495         uint32_t _ptr_portname;
6496         TALLOC_CTX *_mem_save_portname_0;
6497         uint32_t _ptr_drivername;
6498         TALLOC_CTX *_mem_save_drivername_0;
6499         uint32_t _ptr_comment;
6500         TALLOC_CTX *_mem_save_comment_0;
6501         uint32_t _ptr_location;
6502         TALLOC_CTX *_mem_save_location_0;
6503         uint32_t _ptr_devmode;
6504         TALLOC_CTX *_mem_save_devmode_0;
6505         uint32_t _ptr_sepfile;
6506         TALLOC_CTX *_mem_save_sepfile_0;
6507         uint32_t _ptr_printprocessor;
6508         TALLOC_CTX *_mem_save_printprocessor_0;
6509         uint32_t _ptr_datatype;
6510         TALLOC_CTX *_mem_save_datatype_0;
6511         uint32_t _ptr_parameters;
6512         TALLOC_CTX *_mem_save_parameters_0;
6513         uint32_t _ptr_secdesc;
6514         TALLOC_CTX *_mem_save_secdesc_0;
6515         if (ndr_flags & NDR_SCALARS) {
6516                 NDR_CHECK(ndr_pull_align(ndr, 4));
6517                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6518                 if (_ptr_servername) {
6519                         NDR_PULL_ALLOC(ndr, r->servername);
6520                 } else {
6521                         r->servername = NULL;
6522                 }
6523                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6524                 if (_ptr_printername) {
6525                         NDR_PULL_ALLOC(ndr, r->printername);
6526                 } else {
6527                         r->printername = NULL;
6528                 }
6529                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6530                 if (_ptr_sharename) {
6531                         NDR_PULL_ALLOC(ndr, r->sharename);
6532                 } else {
6533                         r->sharename = NULL;
6534                 }
6535                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6536                 if (_ptr_portname) {
6537                         NDR_PULL_ALLOC(ndr, r->portname);
6538                 } else {
6539                         r->portname = NULL;
6540                 }
6541                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6542                 if (_ptr_drivername) {
6543                         NDR_PULL_ALLOC(ndr, r->drivername);
6544                 } else {
6545                         r->drivername = NULL;
6546                 }
6547                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6548                 if (_ptr_comment) {
6549                         NDR_PULL_ALLOC(ndr, r->comment);
6550                 } else {
6551                         r->comment = NULL;
6552                 }
6553                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6554                 if (_ptr_location) {
6555                         NDR_PULL_ALLOC(ndr, r->location);
6556                 } else {
6557                         r->location = NULL;
6558                 }
6559                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
6560                 if (_ptr_devmode) {
6561                         NDR_PULL_ALLOC(ndr, r->devmode);
6562                 } else {
6563                         r->devmode = NULL;
6564                 }
6565                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6566                 if (_ptr_sepfile) {
6567                         NDR_PULL_ALLOC(ndr, r->sepfile);
6568                 } else {
6569                         r->sepfile = NULL;
6570                 }
6571                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6572                 if (_ptr_printprocessor) {
6573                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6574                 } else {
6575                         r->printprocessor = NULL;
6576                 }
6577                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6578                 if (_ptr_datatype) {
6579                         NDR_PULL_ALLOC(ndr, r->datatype);
6580                 } else {
6581                         r->datatype = NULL;
6582                 }
6583                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6584                 if (_ptr_parameters) {
6585                         NDR_PULL_ALLOC(ndr, r->parameters);
6586                 } else {
6587                         r->parameters = NULL;
6588                 }
6589                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
6590                 if (_ptr_secdesc) {
6591                         NDR_PULL_ALLOC(ndr, r->secdesc);
6592                 } else {
6593                         r->secdesc = NULL;
6594                 }
6595                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6596                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6597                 if (r->priority > 99) {
6598                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6599                 }
6600                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
6601                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
6602                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
6603                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6604                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6605                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
6606         }
6607         if (ndr_flags & NDR_BUFFERS) {
6608                 if (r->servername) {
6609                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6610                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6611                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6612                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6613                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6614                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
6615                         }
6616                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6617                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6618                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6619                 }
6620                 if (r->printername) {
6621                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6622                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6623                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6624                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6625                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6626                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
6627                         }
6628                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6629                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6630                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6631                 }
6632                 if (r->sharename) {
6633                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
6634                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
6635                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
6636                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
6637                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
6638                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sharename), ndr_get_array_length(ndr, &r->sharename));
6639                         }
6640                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
6641                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
6642                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
6643                 }
6644                 if (r->portname) {
6645                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6646                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6647                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6648                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6649                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6650                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
6651                         }
6652                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6653                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6654                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6655                 }
6656                 if (r->drivername) {
6657                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6658                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
6659                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
6660                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
6661                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
6662                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->drivername), ndr_get_array_length(ndr, &r->drivername));
6663                         }
6664                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
6665                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
6666                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
6667                 }
6668                 if (r->comment) {
6669                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6670                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6671                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6672                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6673                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6674                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
6675                         }
6676                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6677                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6678                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6679                 }
6680                 if (r->location) {
6681                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
6682                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
6683                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
6684                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
6685                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
6686                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->location), ndr_get_array_length(ndr, &r->location));
6687                         }
6688                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
6689                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
6690                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
6691                 }
6692                 if (r->devmode) {
6693                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
6694                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
6695                         {
6696                                 struct ndr_pull *_ndr_devmode;
6697                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6698                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6699                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
6700                         }
6701                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
6702                 }
6703                 if (r->sepfile) {
6704                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
6705                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
6706                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
6707                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
6708                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
6709                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sepfile), ndr_get_array_length(ndr, &r->sepfile));
6710                         }
6711                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
6712                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
6713                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
6714                 }
6715                 if (r->printprocessor) {
6716                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6717                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
6718                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
6719                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
6720                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
6721                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printprocessor), ndr_get_array_length(ndr, &r->printprocessor));
6722                         }
6723                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
6724                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
6725                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
6726                 }
6727                 if (r->datatype) {
6728                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6729                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
6730                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
6731                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
6732                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
6733                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
6734                         }
6735                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
6736                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
6737                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
6738                 }
6739                 if (r->parameters) {
6740                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6741                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6742                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6743                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6744                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6745                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
6746                         }
6747                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6748                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6749                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6750                 }
6751                 if (r->secdesc) {
6752                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
6753                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
6754                         {
6755                                 struct ndr_pull *_ndr_secdesc;
6756                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6757                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6758                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6759                         }
6760                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
6761                 }
6762         }
6763         return NDR_ERR_SUCCESS;
6764 }
6765
6766 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
6767 {
6768         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
6769         ndr->depth++;
6770         ndr_print_ptr(ndr, "servername", r->servername);
6771         ndr->depth++;
6772         if (r->servername) {
6773                 ndr_print_string(ndr, "servername", r->servername);
6774         }
6775         ndr->depth--;
6776         ndr_print_ptr(ndr, "printername", r->printername);
6777         ndr->depth++;
6778         if (r->printername) {
6779                 ndr_print_string(ndr, "printername", r->printername);
6780         }
6781         ndr->depth--;
6782         ndr_print_ptr(ndr, "sharename", r->sharename);
6783         ndr->depth++;
6784         if (r->sharename) {
6785                 ndr_print_string(ndr, "sharename", r->sharename);
6786         }
6787         ndr->depth--;
6788         ndr_print_ptr(ndr, "portname", r->portname);
6789         ndr->depth++;
6790         if (r->portname) {
6791                 ndr_print_string(ndr, "portname", r->portname);
6792         }
6793         ndr->depth--;
6794         ndr_print_ptr(ndr, "drivername", r->drivername);
6795         ndr->depth++;
6796         if (r->drivername) {
6797                 ndr_print_string(ndr, "drivername", r->drivername);
6798         }
6799         ndr->depth--;
6800         ndr_print_ptr(ndr, "comment", r->comment);
6801         ndr->depth++;
6802         if (r->comment) {
6803                 ndr_print_string(ndr, "comment", r->comment);
6804         }
6805         ndr->depth--;
6806         ndr_print_ptr(ndr, "location", r->location);
6807         ndr->depth++;
6808         if (r->location) {
6809                 ndr_print_string(ndr, "location", r->location);
6810         }
6811         ndr->depth--;
6812         ndr_print_ptr(ndr, "devmode", r->devmode);
6813         ndr->depth++;
6814         if (r->devmode) {
6815                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
6816         }
6817         ndr->depth--;
6818         ndr_print_ptr(ndr, "sepfile", r->sepfile);
6819         ndr->depth++;
6820         if (r->sepfile) {
6821                 ndr_print_string(ndr, "sepfile", r->sepfile);
6822         }
6823         ndr->depth--;
6824         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
6825         ndr->depth++;
6826         if (r->printprocessor) {
6827                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
6828         }
6829         ndr->depth--;
6830         ndr_print_ptr(ndr, "datatype", r->datatype);
6831         ndr->depth++;
6832         if (r->datatype) {
6833                 ndr_print_string(ndr, "datatype", r->datatype);
6834         }
6835         ndr->depth--;
6836         ndr_print_ptr(ndr, "parameters", r->parameters);
6837         ndr->depth++;
6838         if (r->parameters) {
6839                 ndr_print_string(ndr, "parameters", r->parameters);
6840         }
6841         ndr->depth--;
6842         ndr_print_ptr(ndr, "secdesc", r->secdesc);
6843         ndr->depth++;
6844         if (r->secdesc) {
6845                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
6846         }
6847         ndr->depth--;
6848         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6849         ndr_print_uint32(ndr, "priority", r->priority);
6850         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
6851         ndr_print_uint32(ndr, "starttime", r->starttime);
6852         ndr_print_uint32(ndr, "untiltime", r->untiltime);
6853         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
6854         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6855         ndr_print_uint32(ndr, "averageppm", r->averageppm);
6856         ndr->depth--;
6857 }
6858
6859 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
6860 {
6861         if (ndr_flags & NDR_SCALARS) {
6862                 NDR_CHECK(ndr_push_align(ndr, 4));
6863                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
6864         }
6865         if (ndr_flags & NDR_BUFFERS) {
6866         }
6867         return NDR_ERR_SUCCESS;
6868 }
6869
6870 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
6871 {
6872         if (ndr_flags & NDR_SCALARS) {
6873                 NDR_CHECK(ndr_pull_align(ndr, 4));
6874                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
6875         }
6876         if (ndr_flags & NDR_BUFFERS) {
6877         }
6878         return NDR_ERR_SUCCESS;
6879 }
6880
6881 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
6882 {
6883         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
6884         ndr->depth++;
6885         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
6886         ndr->depth--;
6887 }
6888
6889 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
6890 {
6891         if (ndr_flags & NDR_SCALARS) {
6892                 NDR_CHECK(ndr_push_align(ndr, 4));
6893                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6894                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6895                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6896         }
6897         if (ndr_flags & NDR_BUFFERS) {
6898                 if (r->printername) {
6899                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6900                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6901                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6902                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6903                 }
6904                 if (r->servername) {
6905                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6906                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6907                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6908                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6909                 }
6910         }
6911         return NDR_ERR_SUCCESS;
6912 }
6913
6914 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
6915 {
6916         uint32_t _ptr_printername;
6917         TALLOC_CTX *_mem_save_printername_0;
6918         uint32_t _ptr_servername;
6919         TALLOC_CTX *_mem_save_servername_0;
6920         if (ndr_flags & NDR_SCALARS) {
6921                 NDR_CHECK(ndr_pull_align(ndr, 4));
6922                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6923                 if (_ptr_printername) {
6924                         NDR_PULL_ALLOC(ndr, r->printername);
6925                 } else {
6926                         r->printername = NULL;
6927                 }
6928                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6929                 if (_ptr_servername) {
6930                         NDR_PULL_ALLOC(ndr, r->servername);
6931                 } else {
6932                         r->servername = NULL;
6933                 }
6934                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6935         }
6936         if (ndr_flags & NDR_BUFFERS) {
6937                 if (r->printername) {
6938                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6939                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6940                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6941                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6942                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6943                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
6944                         }
6945                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6946                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6947                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6948                 }
6949                 if (r->servername) {
6950                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6951                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6952                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6953                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6954                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6955                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
6956                         }
6957                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6958                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6959                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6960                 }
6961         }
6962         return NDR_ERR_SUCCESS;
6963 }
6964
6965 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
6966 {
6967         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
6968         ndr->depth++;
6969         ndr_print_ptr(ndr, "printername", r->printername);
6970         ndr->depth++;
6971         if (r->printername) {
6972                 ndr_print_string(ndr, "printername", r->printername);
6973         }
6974         ndr->depth--;
6975         ndr_print_ptr(ndr, "servername", r->servername);
6976         ndr->depth++;
6977         if (r->servername) {
6978                 ndr_print_string(ndr, "servername", r->servername);
6979         }
6980         ndr->depth--;
6981         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6982         ndr->depth--;
6983 }
6984
6985 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
6986 {
6987         if (ndr_flags & NDR_SCALARS) {
6988                 NDR_CHECK(ndr_push_align(ndr, 4));
6989                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6990                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6991                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
6993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
6994         }
6995         if (ndr_flags & NDR_BUFFERS) {
6996                 if (r->printername) {
6997                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6998                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6999                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7000                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7001                 }
7002                 if (r->portname) {
7003                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7004                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7005                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7006                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7007                 }
7008         }
7009         return NDR_ERR_SUCCESS;
7010 }
7011
7012 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
7013 {
7014         uint32_t _ptr_printername;
7015         TALLOC_CTX *_mem_save_printername_0;
7016         uint32_t _ptr_portname;
7017         TALLOC_CTX *_mem_save_portname_0;
7018         if (ndr_flags & NDR_SCALARS) {
7019                 NDR_CHECK(ndr_pull_align(ndr, 4));
7020                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7021                 if (_ptr_printername) {
7022                         NDR_PULL_ALLOC(ndr, r->printername);
7023                 } else {
7024                         r->printername = NULL;
7025                 }
7026                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
7027                 if (_ptr_portname) {
7028                         NDR_PULL_ALLOC(ndr, r->portname);
7029                 } else {
7030                         r->portname = NULL;
7031                 }
7032                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7033                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
7034                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
7035         }
7036         if (ndr_flags & NDR_BUFFERS) {
7037                 if (r->printername) {
7038                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7039                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7040                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7041                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7042                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7043                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
7044                         }
7045                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7046                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7047                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7048                 }
7049                 if (r->portname) {
7050                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7051                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7052                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7053                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7054                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7055                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
7056                         }
7057                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7058                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7059                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7060                 }
7061         }
7062         return NDR_ERR_SUCCESS;
7063 }
7064
7065 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
7066 {
7067         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
7068         ndr->depth++;
7069         ndr_print_ptr(ndr, "printername", r->printername);
7070         ndr->depth++;
7071         if (r->printername) {
7072                 ndr_print_string(ndr, "printername", r->printername);
7073         }
7074         ndr->depth--;
7075         ndr_print_ptr(ndr, "portname", r->portname);
7076         ndr->depth++;
7077         if (r->portname) {
7078                 ndr_print_string(ndr, "portname", r->portname);
7079         }
7080         ndr->depth--;
7081         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7082         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
7083         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
7084         ndr->depth--;
7085 }
7086
7087 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
7088 {
7089         if (ndr_flags & NDR_SCALARS) {
7090                 NDR_CHECK(ndr_push_align(ndr, 4));
7091                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
7092         }
7093         if (ndr_flags & NDR_BUFFERS) {
7094         }
7095         return NDR_ERR_SUCCESS;
7096 }
7097
7098 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
7099 {
7100         if (ndr_flags & NDR_SCALARS) {
7101                 NDR_CHECK(ndr_pull_align(ndr, 4));
7102                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7103         }
7104         if (ndr_flags & NDR_BUFFERS) {
7105         }
7106         return NDR_ERR_SUCCESS;
7107 }
7108
7109 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
7110 {
7111         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
7112         ndr->depth++;
7113         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7114         ndr->depth--;
7115 }
7116
7117 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
7118 {
7119         if (ndr_flags & NDR_SCALARS) {
7120                 NDR_CHECK(ndr_push_align(ndr, 4));
7121                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
7122                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
7123         }
7124         if (ndr_flags & NDR_BUFFERS) {
7125                 if (r->guid) {
7126                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7127                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7128                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7129                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7130                 }
7131         }
7132         return NDR_ERR_SUCCESS;
7133 }
7134
7135 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
7136 {
7137         uint32_t _ptr_guid;
7138         TALLOC_CTX *_mem_save_guid_0;
7139         if (ndr_flags & NDR_SCALARS) {
7140                 NDR_CHECK(ndr_pull_align(ndr, 4));
7141                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
7142                 if (_ptr_guid) {
7143                         NDR_PULL_ALLOC(ndr, r->guid);
7144                 } else {
7145                         r->guid = NULL;
7146                 }
7147                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
7148         }
7149         if (ndr_flags & NDR_BUFFERS) {
7150                 if (r->guid) {
7151                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7152                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
7153                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
7154                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
7155                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
7156                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->guid), ndr_get_array_length(ndr, &r->guid));
7157                         }
7158                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
7159                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
7160                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
7161                 }
7162         }
7163         return NDR_ERR_SUCCESS;
7164 }
7165
7166 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
7167 {
7168         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
7169         ndr->depth++;
7170         ndr_print_ptr(ndr, "guid", r->guid);
7171         ndr->depth++;
7172         if (r->guid) {
7173                 ndr_print_string(ndr, "guid", r->guid);
7174         }
7175         ndr->depth--;
7176         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
7177         ndr->depth--;
7178 }
7179
7180 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
7181 {
7182         if (ndr_flags & NDR_SCALARS) {
7183                 int level = ndr_push_get_switch_value(ndr, r);
7184                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
7185                 switch (level) {
7186                         case 0: {
7187                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
7188                         break; }
7189
7190                         case 1: {
7191                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
7192                         break; }
7193
7194                         case 2: {
7195                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
7196                         break; }
7197
7198                         case 3: {
7199                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
7200                         break; }
7201
7202                         case 4: {
7203                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
7204                         break; }
7205
7206                         case 5: {
7207                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
7208                         break; }
7209
7210                         case 6: {
7211                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
7212                         break; }
7213
7214                         case 7: {
7215                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
7216                         break; }
7217
7218                         case 8: {
7219                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
7220                         break; }
7221
7222                         case 9: {
7223                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
7224                         break; }
7225
7226                         default: {
7227                         break; }
7228
7229                 }
7230         }
7231         if (ndr_flags & NDR_BUFFERS) {
7232                 int level = ndr_push_get_switch_value(ndr, r);
7233                 switch (level) {
7234                         case 0:
7235                                 if (r->info0) {
7236                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7237                                 }
7238                         break;
7239
7240                         case 1:
7241                                 if (r->info1) {
7242                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7243                                 }
7244                         break;
7245
7246                         case 2:
7247                                 if (r->info2) {
7248                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7249                                 }
7250                         break;
7251
7252                         case 3:
7253                                 if (r->info3) {
7254                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7255                                 }
7256                         break;
7257
7258                         case 4:
7259                                 if (r->info4) {
7260                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7261                                 }
7262                         break;
7263
7264                         case 5:
7265                                 if (r->info5) {
7266                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7267                                 }
7268                         break;
7269
7270                         case 6:
7271                                 if (r->info6) {
7272                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7273                                 }
7274                         break;
7275
7276                         case 7:
7277                                 if (r->info7) {
7278                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7279                                 }
7280                         break;
7281
7282                         case 8:
7283                                 if (r->info8) {
7284                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7285                                 }
7286                         break;
7287
7288                         case 9:
7289                                 if (r->info9) {
7290                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7291                                 }
7292                         break;
7293
7294                         default:
7295                         break;
7296
7297                 }
7298         }
7299         return NDR_ERR_SUCCESS;
7300 }
7301
7302 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
7303 {
7304         int level;
7305         uint32_t _level;
7306         TALLOC_CTX *_mem_save_info0_0;
7307         TALLOC_CTX *_mem_save_info1_0;
7308         TALLOC_CTX *_mem_save_info2_0;
7309         TALLOC_CTX *_mem_save_info3_0;
7310         TALLOC_CTX *_mem_save_info4_0;
7311         TALLOC_CTX *_mem_save_info5_0;
7312         TALLOC_CTX *_mem_save_info6_0;
7313         TALLOC_CTX *_mem_save_info7_0;
7314         TALLOC_CTX *_mem_save_info8_0;
7315         TALLOC_CTX *_mem_save_info9_0;
7316         level = ndr_pull_get_switch_value(ndr, r);
7317         if (ndr_flags & NDR_SCALARS) {
7318                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7319                 if (_level != level) {
7320                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
7321                 }
7322                 switch (level) {
7323                         case 0: {
7324                                 uint32_t _ptr_info0;
7325                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
7326                                 if (_ptr_info0) {
7327                                         NDR_PULL_ALLOC(ndr, r->info0);
7328                                 } else {
7329                                         r->info0 = NULL;
7330                                 }
7331                         break; }
7332
7333                         case 1: {
7334                                 uint32_t _ptr_info1;
7335                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
7336                                 if (_ptr_info1) {
7337                                         NDR_PULL_ALLOC(ndr, r->info1);
7338                                 } else {
7339                                         r->info1 = NULL;
7340                                 }
7341                         break; }
7342
7343                         case 2: {
7344                                 uint32_t _ptr_info2;
7345                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
7346                                 if (_ptr_info2) {
7347                                         NDR_PULL_ALLOC(ndr, r->info2);
7348                                 } else {
7349                                         r->info2 = NULL;
7350                                 }
7351                         break; }
7352
7353                         case 3: {
7354                                 uint32_t _ptr_info3;
7355                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7356                                 if (_ptr_info3) {
7357                                         NDR_PULL_ALLOC(ndr, r->info3);
7358                                 } else {
7359                                         r->info3 = NULL;
7360                                 }
7361                         break; }
7362
7363                         case 4: {
7364                                 uint32_t _ptr_info4;
7365                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7366                                 if (_ptr_info4) {
7367                                         NDR_PULL_ALLOC(ndr, r->info4);
7368                                 } else {
7369                                         r->info4 = NULL;
7370                                 }
7371                         break; }
7372
7373                         case 5: {
7374                                 uint32_t _ptr_info5;
7375                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7376                                 if (_ptr_info5) {
7377                                         NDR_PULL_ALLOC(ndr, r->info5);
7378                                 } else {
7379                                         r->info5 = NULL;
7380                                 }
7381                         break; }
7382
7383                         case 6: {
7384                                 uint32_t _ptr_info6;
7385                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7386                                 if (_ptr_info6) {
7387                                         NDR_PULL_ALLOC(ndr, r->info6);
7388                                 } else {
7389                                         r->info6 = NULL;
7390                                 }
7391                         break; }
7392
7393                         case 7: {
7394                                 uint32_t _ptr_info7;
7395                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7396                                 if (_ptr_info7) {
7397                                         NDR_PULL_ALLOC(ndr, r->info7);
7398                                 } else {
7399                                         r->info7 = NULL;
7400                                 }
7401                         break; }
7402
7403                         case 8: {
7404                                 uint32_t _ptr_info8;
7405                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7406                                 if (_ptr_info8) {
7407                                         NDR_PULL_ALLOC(ndr, r->info8);
7408                                 } else {
7409                                         r->info8 = NULL;
7410                                 }
7411                         break; }
7412
7413                         case 9: {
7414                                 uint32_t _ptr_info9;
7415                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7416                                 if (_ptr_info9) {
7417                                         NDR_PULL_ALLOC(ndr, r->info9);
7418                                 } else {
7419                                         r->info9 = NULL;
7420                                 }
7421                         break; }
7422
7423                         default: {
7424                         break; }
7425
7426                 }
7427         }
7428         if (ndr_flags & NDR_BUFFERS) {
7429                 switch (level) {
7430                         case 0:
7431                                 if (r->info0) {
7432                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7433                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7434                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7435                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7436                                 }
7437                         break;
7438
7439                         case 1:
7440                                 if (r->info1) {
7441                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7442                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7443                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7444                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7445                                 }
7446                         break;
7447
7448                         case 2:
7449                                 if (r->info2) {
7450                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7451                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7452                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7453                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7454                                 }
7455                         break;
7456
7457                         case 3:
7458                                 if (r->info3) {
7459                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7460                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7461                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7462                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7463                                 }
7464                         break;
7465
7466                         case 4:
7467                                 if (r->info4) {
7468                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7469                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7470                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7471                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7472                                 }
7473                         break;
7474
7475                         case 5:
7476                                 if (r->info5) {
7477                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7478                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7479                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7480                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7481                                 }
7482                         break;
7483
7484                         case 6:
7485                                 if (r->info6) {
7486                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7487                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7488                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7489                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7490                                 }
7491                         break;
7492
7493                         case 7:
7494                                 if (r->info7) {
7495                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7496                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7497                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7498                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7499                                 }
7500                         break;
7501
7502                         case 8:
7503                                 if (r->info8) {
7504                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7505                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7506                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7507                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7508                                 }
7509                         break;
7510
7511                         case 9:
7512                                 if (r->info9) {
7513                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7514                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7515                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7516                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7517                                 }
7518                         break;
7519
7520                         default:
7521                         break;
7522
7523                 }
7524         }
7525         return NDR_ERR_SUCCESS;
7526 }
7527
7528 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7529 {
7530         int level;
7531         level = ndr_print_get_switch_value(ndr, r);
7532         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7533         switch (level) {
7534                 case 0:
7535                         ndr_print_ptr(ndr, "info0", r->info0);
7536                         ndr->depth++;
7537                         if (r->info0) {
7538                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
7539                         }
7540                         ndr->depth--;
7541                 break;
7542
7543                 case 1:
7544                         ndr_print_ptr(ndr, "info1", r->info1);
7545                         ndr->depth++;
7546                         if (r->info1) {
7547                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
7548                         }
7549                         ndr->depth--;
7550                 break;
7551
7552                 case 2:
7553                         ndr_print_ptr(ndr, "info2", r->info2);
7554                         ndr->depth++;
7555                         if (r->info2) {
7556                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
7557                         }
7558                         ndr->depth--;
7559                 break;
7560
7561                 case 3:
7562                         ndr_print_ptr(ndr, "info3", r->info3);
7563                         ndr->depth++;
7564                         if (r->info3) {
7565                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
7566                         }
7567                         ndr->depth--;
7568                 break;
7569
7570                 case 4:
7571                         ndr_print_ptr(ndr, "info4", r->info4);
7572                         ndr->depth++;
7573                         if (r->info4) {
7574                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
7575                         }
7576                         ndr->depth--;
7577                 break;
7578
7579                 case 5:
7580                         ndr_print_ptr(ndr, "info5", r->info5);
7581                         ndr->depth++;
7582                         if (r->info5) {
7583                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
7584                         }
7585                         ndr->depth--;
7586                 break;
7587
7588                 case 6:
7589                         ndr_print_ptr(ndr, "info6", r->info6);
7590                         ndr->depth++;
7591                         if (r->info6) {
7592                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
7593                         }
7594                         ndr->depth--;
7595                 break;
7596
7597                 case 7:
7598                         ndr_print_ptr(ndr, "info7", r->info7);
7599                         ndr->depth++;
7600                         if (r->info7) {
7601                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
7602                         }
7603                         ndr->depth--;
7604                 break;
7605
7606                 case 8:
7607                         ndr_print_ptr(ndr, "info8", r->info8);
7608                         ndr->depth++;
7609                         if (r->info8) {
7610                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
7611                         }
7612                         ndr->depth--;
7613                 break;
7614
7615                 case 9:
7616                         ndr_print_ptr(ndr, "info9", r->info9);
7617                         ndr->depth++;
7618                         if (r->info9) {
7619                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
7620                         }
7621                         ndr->depth--;
7622                 break;
7623
7624                 default:
7625                 break;
7626
7627         }
7628 }
7629
7630 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
7631 {
7632         if (ndr_flags & NDR_SCALARS) {
7633                 NDR_CHECK(ndr_push_align(ndr, 4));
7634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7635                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
7636                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7637         }
7638         if (ndr_flags & NDR_BUFFERS) {
7639                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7640         }
7641         return NDR_ERR_SUCCESS;
7642 }
7643
7644 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
7645 {
7646         if (ndr_flags & NDR_SCALARS) {
7647                 NDR_CHECK(ndr_pull_align(ndr, 4));
7648                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7649                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
7650                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7651         }
7652         if (ndr_flags & NDR_BUFFERS) {
7653                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7654         }
7655         return NDR_ERR_SUCCESS;
7656 }
7657
7658 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
7659 {
7660         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
7661         ndr->depth++;
7662         ndr_print_uint32(ndr, "level", r->level);
7663         ndr_print_set_switch_value(ndr, &r->info, r->level);
7664         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
7665         ndr->depth--;
7666 }
7667
7668 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
7669 {
7670         if (ndr_flags & NDR_SCALARS) {
7671                 NDR_CHECK(ndr_push_align(ndr, 4));
7672                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
7673                 {
7674                         uint32_t _flags_save_string_array = ndr->flags;
7675                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7676                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
7677                         ndr->flags = _flags_save_string_array;
7678                 }
7679         }
7680         if (ndr_flags & NDR_BUFFERS) {
7681         }
7682         return NDR_ERR_SUCCESS;
7683 }
7684
7685 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
7686 {
7687         if (ndr_flags & NDR_SCALARS) {
7688                 NDR_CHECK(ndr_pull_align(ndr, 4));
7689                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
7690                 {
7691                         uint32_t _flags_save_string_array = ndr->flags;
7692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7693                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
7694                         ndr->flags = _flags_save_string_array;
7695                 }
7696         }
7697         if (ndr_flags & NDR_BUFFERS) {
7698         }
7699         return NDR_ERR_SUCCESS;
7700 }
7701
7702 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
7703 {
7704         ndr_print_struct(ndr, name, "spoolss_StringArray");
7705         ndr->depth++;
7706         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2:r->_ndr_size);
7707         ndr_print_string_array(ndr, "string", r->string);
7708         ndr->depth--;
7709 }
7710
7711 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
7712 {
7713         if (ndr_flags & NDR_SCALARS) {
7714                 NDR_CHECK(ndr_push_align(ndr, 4));
7715                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7716         }
7717         if (ndr_flags & NDR_BUFFERS) {
7718                 if (r->driver_name) {
7719                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7720                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7721                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7722                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7723                 }
7724         }
7725         return NDR_ERR_SUCCESS;
7726 }
7727
7728 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
7729 {
7730         uint32_t _ptr_driver_name;
7731         TALLOC_CTX *_mem_save_driver_name_0;
7732         if (ndr_flags & NDR_SCALARS) {
7733                 NDR_CHECK(ndr_pull_align(ndr, 4));
7734                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7735                 if (_ptr_driver_name) {
7736                         NDR_PULL_ALLOC(ndr, r->driver_name);
7737                 } else {
7738                         r->driver_name = NULL;
7739                 }
7740         }
7741         if (ndr_flags & NDR_BUFFERS) {
7742                 if (r->driver_name) {
7743                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7744                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7745                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7746                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7747                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7748                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
7749                         }
7750                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7751                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7752                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7753                 }
7754         }
7755         return NDR_ERR_SUCCESS;
7756 }
7757
7758 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
7759 {
7760         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
7761         ndr->depth++;
7762         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7763         ndr->depth++;
7764         if (r->driver_name) {
7765                 ndr_print_string(ndr, "driver_name", r->driver_name);
7766         }
7767         ndr->depth--;
7768         ndr->depth--;
7769 }
7770
7771 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
7772 {
7773         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
7774         return NDR_ERR_SUCCESS;
7775 }
7776
7777 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
7778 {
7779         uint32_t v;
7780         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
7781         *r = v;
7782         return NDR_ERR_SUCCESS;
7783 }
7784
7785 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
7786 {
7787         const char *val = NULL;
7788
7789         switch (r) {
7790                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
7791                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
7792                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
7793                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
7794         }
7795         ndr_print_enum(ndr, name, "ENUM", val, r);
7796 }
7797
7798 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
7799 {
7800         if (ndr_flags & NDR_SCALARS) {
7801                 NDR_CHECK(ndr_push_align(ndr, 4));
7802                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7803                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7804                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7805                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7806                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7807                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7808         }
7809         if (ndr_flags & NDR_BUFFERS) {
7810                 if (r->driver_name) {
7811                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7812                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7813                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7814                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7815                 }
7816                 if (r->architecture) {
7817                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7818                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7819                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7820                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7821                 }
7822                 if (r->driver_path) {
7823                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7824                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7825                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7826                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7827                 }
7828                 if (r->data_file) {
7829                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7830                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7831                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7832                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7833                 }
7834                 if (r->config_file) {
7835                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7836                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7837                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7838                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7839                 }
7840         }
7841         return NDR_ERR_SUCCESS;
7842 }
7843
7844 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
7845 {
7846         uint32_t _ptr_driver_name;
7847         TALLOC_CTX *_mem_save_driver_name_0;
7848         uint32_t _ptr_architecture;
7849         TALLOC_CTX *_mem_save_architecture_0;
7850         uint32_t _ptr_driver_path;
7851         TALLOC_CTX *_mem_save_driver_path_0;
7852         uint32_t _ptr_data_file;
7853         TALLOC_CTX *_mem_save_data_file_0;
7854         uint32_t _ptr_config_file;
7855         TALLOC_CTX *_mem_save_config_file_0;
7856         if (ndr_flags & NDR_SCALARS) {
7857                 NDR_CHECK(ndr_pull_align(ndr, 4));
7858                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7859                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7860                 if (_ptr_driver_name) {
7861                         NDR_PULL_ALLOC(ndr, r->driver_name);
7862                 } else {
7863                         r->driver_name = NULL;
7864                 }
7865                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7866                 if (_ptr_architecture) {
7867                         NDR_PULL_ALLOC(ndr, r->architecture);
7868                 } else {
7869                         r->architecture = NULL;
7870                 }
7871                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7872                 if (_ptr_driver_path) {
7873                         NDR_PULL_ALLOC(ndr, r->driver_path);
7874                 } else {
7875                         r->driver_path = NULL;
7876                 }
7877                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7878                 if (_ptr_data_file) {
7879                         NDR_PULL_ALLOC(ndr, r->data_file);
7880                 } else {
7881                         r->data_file = NULL;
7882                 }
7883                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7884                 if (_ptr_config_file) {
7885                         NDR_PULL_ALLOC(ndr, r->config_file);
7886                 } else {
7887                         r->config_file = NULL;
7888                 }
7889         }
7890         if (ndr_flags & NDR_BUFFERS) {
7891                 if (r->driver_name) {
7892                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7893                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7894                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7895                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7896                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7897                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
7898                         }
7899                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7900                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7901                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7902                 }
7903                 if (r->architecture) {
7904                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7905                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7906                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7907                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7908                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7909                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
7910                         }
7911                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7912                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7913                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7914                 }
7915                 if (r->driver_path) {
7916                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7917                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7918                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7919                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7920                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7921                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
7922                         }
7923                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7924                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7925                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7926                 }
7927                 if (r->data_file) {
7928                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7929                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7930                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7931                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7932                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7933                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
7934                         }
7935                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7936                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7937                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7938                 }
7939                 if (r->config_file) {
7940                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7941                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7942                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7943                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7944                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7945                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
7946                         }
7947                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7948                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7949                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7950                 }
7951         }
7952         return NDR_ERR_SUCCESS;
7953 }
7954
7955 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
7956 {
7957         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
7958         ndr->depth++;
7959         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7960         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7961         ndr->depth++;
7962         if (r->driver_name) {
7963                 ndr_print_string(ndr, "driver_name", r->driver_name);
7964         }
7965         ndr->depth--;
7966         ndr_print_ptr(ndr, "architecture", r->architecture);
7967         ndr->depth++;
7968         if (r->architecture) {
7969                 ndr_print_string(ndr, "architecture", r->architecture);
7970         }
7971         ndr->depth--;
7972         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7973         ndr->depth++;
7974         if (r->driver_path) {
7975                 ndr_print_string(ndr, "driver_path", r->driver_path);
7976         }
7977         ndr->depth--;
7978         ndr_print_ptr(ndr, "data_file", r->data_file);
7979         ndr->depth++;
7980         if (r->data_file) {
7981                 ndr_print_string(ndr, "data_file", r->data_file);
7982         }
7983         ndr->depth--;
7984         ndr_print_ptr(ndr, "config_file", r->config_file);
7985         ndr->depth++;
7986         if (r->config_file) {
7987                 ndr_print_string(ndr, "config_file", r->config_file);
7988         }
7989         ndr->depth--;
7990         ndr->depth--;
7991 }
7992
7993 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
7994 {
7995         if (ndr_flags & NDR_SCALARS) {
7996                 NDR_CHECK(ndr_push_align(ndr, 4));
7997                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7998                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7999                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8000                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8001                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8002                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8003                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8004                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8005                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8006                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8007                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8008         }
8009         if (ndr_flags & NDR_BUFFERS) {
8010                 if (r->driver_name) {
8011                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8012                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8013                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8014                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8015                 }
8016                 if (r->architecture) {
8017                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8018                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8019                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8020                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8021                 }
8022                 if (r->driver_path) {
8023                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8024                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8025                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8026                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8027                 }
8028                 if (r->data_file) {
8029                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8030                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8031                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8032                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8033                 }
8034                 if (r->config_file) {
8035                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8036                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8037                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8038                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8039                 }
8040                 if (r->help_file) {
8041                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8042                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8043                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8044                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8045                 }
8046                 if (r->monitor_name) {
8047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8048                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8049                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8050                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8051                 }
8052                 if (r->default_datatype) {
8053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8056                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8057                 }
8058                 if (r->dependent_files) {
8059                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8060                 }
8061         }
8062         return NDR_ERR_SUCCESS;
8063 }
8064
8065 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
8066 {
8067         uint32_t _ptr_driver_name;
8068         TALLOC_CTX *_mem_save_driver_name_0;
8069         uint32_t _ptr_architecture;
8070         TALLOC_CTX *_mem_save_architecture_0;
8071         uint32_t _ptr_driver_path;
8072         TALLOC_CTX *_mem_save_driver_path_0;
8073         uint32_t _ptr_data_file;
8074         TALLOC_CTX *_mem_save_data_file_0;
8075         uint32_t _ptr_config_file;
8076         TALLOC_CTX *_mem_save_config_file_0;
8077         uint32_t _ptr_help_file;
8078         TALLOC_CTX *_mem_save_help_file_0;
8079         uint32_t _ptr_monitor_name;
8080         TALLOC_CTX *_mem_save_monitor_name_0;
8081         uint32_t _ptr_default_datatype;
8082         TALLOC_CTX *_mem_save_default_datatype_0;
8083         uint32_t _ptr_dependent_files;
8084         TALLOC_CTX *_mem_save_dependent_files_0;
8085         if (ndr_flags & NDR_SCALARS) {
8086                 NDR_CHECK(ndr_pull_align(ndr, 4));
8087                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8088                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8089                 if (_ptr_driver_name) {
8090                         NDR_PULL_ALLOC(ndr, r->driver_name);
8091                 } else {
8092                         r->driver_name = NULL;
8093                 }
8094                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8095                 if (_ptr_architecture) {
8096                         NDR_PULL_ALLOC(ndr, r->architecture);
8097                 } else {
8098                         r->architecture = NULL;
8099                 }
8100                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8101                 if (_ptr_driver_path) {
8102                         NDR_PULL_ALLOC(ndr, r->driver_path);
8103                 } else {
8104                         r->driver_path = NULL;
8105                 }
8106                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8107                 if (_ptr_data_file) {
8108                         NDR_PULL_ALLOC(ndr, r->data_file);
8109                 } else {
8110                         r->data_file = NULL;
8111                 }
8112                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8113                 if (_ptr_config_file) {
8114                         NDR_PULL_ALLOC(ndr, r->config_file);
8115                 } else {
8116                         r->config_file = NULL;
8117                 }
8118                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8119                 if (_ptr_help_file) {
8120                         NDR_PULL_ALLOC(ndr, r->help_file);
8121                 } else {
8122                         r->help_file = NULL;
8123                 }
8124                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8125                 if (_ptr_monitor_name) {
8126                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8127                 } else {
8128                         r->monitor_name = NULL;
8129                 }
8130                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8131                 if (_ptr_default_datatype) {
8132                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8133                 } else {
8134                         r->default_datatype = NULL;
8135                 }
8136                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8137                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8138                 if (_ptr_dependent_files) {
8139                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8140                 } else {
8141                         r->dependent_files = NULL;
8142                 }
8143         }
8144         if (ndr_flags & NDR_BUFFERS) {
8145                 if (r->driver_name) {
8146                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8147                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8148                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8149                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8150                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8151                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8152                         }
8153                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8154                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8155                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8156                 }
8157                 if (r->architecture) {
8158                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8159                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8160                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8161                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8162                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8163                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8164                         }
8165                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8166                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8167                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8168                 }
8169                 if (r->driver_path) {
8170                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8171                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8172                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8173                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8174                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8175                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8176                         }
8177                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8178                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8179                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8180                 }
8181                 if (r->data_file) {
8182                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8183                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8184                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8185                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8186                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8187                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8188                         }
8189                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8190                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8192                 }
8193                 if (r->config_file) {
8194                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8195                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8196                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8197                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8198                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8199                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8200                         }
8201                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8202                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8204                 }
8205                 if (r->help_file) {
8206                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8207                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8208                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8209                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8210                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8211                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8212                         }
8213                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8214                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8215                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8216                 }
8217                 if (r->monitor_name) {
8218                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8219                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8220                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8221                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8222                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8223                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
8224                         }
8225                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8226                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8227                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8228                 }
8229                 if (r->default_datatype) {
8230                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8231                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8232                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8233                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8234                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8235                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
8236                         }
8237                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8238                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8240                 }
8241                 if (r->dependent_files) {
8242                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8243                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8244                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8245                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8246                 }
8247         }
8248         return NDR_ERR_SUCCESS;
8249 }
8250
8251 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
8252 {
8253         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
8254         ndr->depth++;
8255         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8256         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8257         ndr->depth++;
8258         if (r->driver_name) {
8259                 ndr_print_string(ndr, "driver_name", r->driver_name);
8260         }
8261         ndr->depth--;
8262         ndr_print_ptr(ndr, "architecture", r->architecture);
8263         ndr->depth++;
8264         if (r->architecture) {
8265                 ndr_print_string(ndr, "architecture", r->architecture);
8266         }
8267         ndr->depth--;
8268         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8269         ndr->depth++;
8270         if (r->driver_path) {
8271                 ndr_print_string(ndr, "driver_path", r->driver_path);
8272         }
8273         ndr->depth--;
8274         ndr_print_ptr(ndr, "data_file", r->data_file);
8275         ndr->depth++;
8276         if (r->data_file) {
8277                 ndr_print_string(ndr, "data_file", r->data_file);
8278         }
8279         ndr->depth--;
8280         ndr_print_ptr(ndr, "config_file", r->config_file);
8281         ndr->depth++;
8282         if (r->config_file) {
8283                 ndr_print_string(ndr, "config_file", r->config_file);
8284         }
8285         ndr->depth--;
8286         ndr_print_ptr(ndr, "help_file", r->help_file);
8287         ndr->depth++;
8288         if (r->help_file) {
8289                 ndr_print_string(ndr, "help_file", r->help_file);
8290         }
8291         ndr->depth--;
8292         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8293         ndr->depth++;
8294         if (r->monitor_name) {
8295                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8296         }
8297         ndr->depth--;
8298         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8299         ndr->depth++;
8300         if (r->default_datatype) {
8301                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8302         }
8303         ndr->depth--;
8304         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
8305         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8306         ndr->depth++;
8307         if (r->dependent_files) {
8308                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8309         }
8310         ndr->depth--;
8311         ndr->depth--;
8312 }
8313
8314 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
8315 {
8316         if (ndr_flags & NDR_SCALARS) {
8317                 NDR_CHECK(ndr_push_align(ndr, 4));
8318                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8319                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8320                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8321                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8322                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8323                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8324                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8325                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8326                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8328                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8330                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8331         }
8332         if (ndr_flags & NDR_BUFFERS) {
8333                 if (r->driver_name) {
8334                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8335                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8336                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8337                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8338                 }
8339                 if (r->architecture) {
8340                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8341                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8342                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8343                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8344                 }
8345                 if (r->driver_path) {
8346                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8347                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8348                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8349                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8350                 }
8351                 if (r->data_file) {
8352                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8353                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8354                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8355                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8356                 }
8357                 if (r->config_file) {
8358                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8359                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8360                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8361                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8362                 }
8363                 if (r->help_file) {
8364                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8365                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8366                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8367                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8368                 }
8369                 if (r->monitor_name) {
8370                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8371                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8372                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8373                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8374                 }
8375                 if (r->default_datatype) {
8376                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8377                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8378                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8379                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8380                 }
8381                 if (r->dependent_files) {
8382                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8383                 }
8384                 if (r->previous_names) {
8385                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8386                 }
8387         }
8388         return NDR_ERR_SUCCESS;
8389 }
8390
8391 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8392 {
8393         uint32_t _ptr_driver_name;
8394         TALLOC_CTX *_mem_save_driver_name_0;
8395         uint32_t _ptr_architecture;
8396         TALLOC_CTX *_mem_save_architecture_0;
8397         uint32_t _ptr_driver_path;
8398         TALLOC_CTX *_mem_save_driver_path_0;
8399         uint32_t _ptr_data_file;
8400         TALLOC_CTX *_mem_save_data_file_0;
8401         uint32_t _ptr_config_file;
8402         TALLOC_CTX *_mem_save_config_file_0;
8403         uint32_t _ptr_help_file;
8404         TALLOC_CTX *_mem_save_help_file_0;
8405         uint32_t _ptr_monitor_name;
8406         TALLOC_CTX *_mem_save_monitor_name_0;
8407         uint32_t _ptr_default_datatype;
8408         TALLOC_CTX *_mem_save_default_datatype_0;
8409         uint32_t _ptr_dependent_files;
8410         TALLOC_CTX *_mem_save_dependent_files_0;
8411         uint32_t _ptr_previous_names;
8412         TALLOC_CTX *_mem_save_previous_names_0;
8413         if (ndr_flags & NDR_SCALARS) {
8414                 NDR_CHECK(ndr_pull_align(ndr, 4));
8415                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8416                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8417                 if (_ptr_driver_name) {
8418                         NDR_PULL_ALLOC(ndr, r->driver_name);
8419                 } else {
8420                         r->driver_name = NULL;
8421                 }
8422                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8423                 if (_ptr_architecture) {
8424                         NDR_PULL_ALLOC(ndr, r->architecture);
8425                 } else {
8426                         r->architecture = NULL;
8427                 }
8428                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8429                 if (_ptr_driver_path) {
8430                         NDR_PULL_ALLOC(ndr, r->driver_path);
8431                 } else {
8432                         r->driver_path = NULL;
8433                 }
8434                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8435                 if (_ptr_data_file) {
8436                         NDR_PULL_ALLOC(ndr, r->data_file);
8437                 } else {
8438                         r->data_file = NULL;
8439                 }
8440                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8441                 if (_ptr_config_file) {
8442                         NDR_PULL_ALLOC(ndr, r->config_file);
8443                 } else {
8444                         r->config_file = NULL;
8445                 }
8446                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8447                 if (_ptr_help_file) {
8448                         NDR_PULL_ALLOC(ndr, r->help_file);
8449                 } else {
8450                         r->help_file = NULL;
8451                 }
8452                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8453                 if (_ptr_monitor_name) {
8454                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8455                 } else {
8456                         r->monitor_name = NULL;
8457                 }
8458                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8459                 if (_ptr_default_datatype) {
8460                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8461                 } else {
8462                         r->default_datatype = NULL;
8463                 }
8464                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8465                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8466                 if (_ptr_dependent_files) {
8467                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8468                 } else {
8469                         r->dependent_files = NULL;
8470                 }
8471                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8472                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8473                 if (_ptr_previous_names) {
8474                         NDR_PULL_ALLOC(ndr, r->previous_names);
8475                 } else {
8476                         r->previous_names = NULL;
8477                 }
8478         }
8479         if (ndr_flags & NDR_BUFFERS) {
8480                 if (r->driver_name) {
8481                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8482                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8483                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8484                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8485                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8486                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8487                         }
8488                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8489                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8490                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8491                 }
8492                 if (r->architecture) {
8493                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8494                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8495                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8496                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8497                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8498                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8499                         }
8500                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8501                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8502                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8503                 }
8504                 if (r->driver_path) {
8505                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8506                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8507                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8508                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8509                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8510                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8511                         }
8512                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8513                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8514                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8515                 }
8516                 if (r->data_file) {
8517                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8518                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8519                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8520                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8521                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8522                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8523                         }
8524                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8525                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8526                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8527                 }
8528                 if (r->config_file) {
8529                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8530                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8531                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8532                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8533                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8534                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8535                         }
8536                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8537                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8538                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8539                 }
8540                 if (r->help_file) {
8541                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8542                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8543                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8544                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8545                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8546                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8547                         }
8548                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8549                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8550                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8551                 }
8552                 if (r->monitor_name) {
8553                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8554                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8555                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8556                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8557                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8558                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
8559                         }
8560                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8561                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8562                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8563                 }
8564                 if (r->default_datatype) {
8565                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8566                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8567                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8568                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8569                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8570                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
8571                         }
8572                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8573                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8574                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8575                 }
8576                 if (r->dependent_files) {
8577                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8578                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8579                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8580                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8581                 }
8582                 if (r->previous_names) {
8583                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8584                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8585                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8586                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8587                 }
8588         }
8589         return NDR_ERR_SUCCESS;
8590 }
8591
8592 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
8593 {
8594         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
8595         ndr->depth++;
8596         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8597         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8598         ndr->depth++;
8599         if (r->driver_name) {
8600                 ndr_print_string(ndr, "driver_name", r->driver_name);
8601         }
8602         ndr->depth--;
8603         ndr_print_ptr(ndr, "architecture", r->architecture);
8604         ndr->depth++;
8605         if (r->architecture) {
8606                 ndr_print_string(ndr, "architecture", r->architecture);
8607         }
8608         ndr->depth--;
8609         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8610         ndr->depth++;
8611         if (r->driver_path) {
8612                 ndr_print_string(ndr, "driver_path", r->driver_path);
8613         }
8614         ndr->depth--;
8615         ndr_print_ptr(ndr, "data_file", r->data_file);
8616         ndr->depth++;
8617         if (r->data_file) {
8618                 ndr_print_string(ndr, "data_file", r->data_file);
8619         }
8620         ndr->depth--;
8621         ndr_print_ptr(ndr, "config_file", r->config_file);
8622         ndr->depth++;
8623         if (r->config_file) {
8624                 ndr_print_string(ndr, "config_file", r->config_file);
8625         }
8626         ndr->depth--;
8627         ndr_print_ptr(ndr, "help_file", r->help_file);
8628         ndr->depth++;
8629         if (r->help_file) {
8630                 ndr_print_string(ndr, "help_file", r->help_file);
8631         }
8632         ndr->depth--;
8633         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8634         ndr->depth++;
8635         if (r->monitor_name) {
8636                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8637         }
8638         ndr->depth--;
8639         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8640         ndr->depth++;
8641         if (r->default_datatype) {
8642                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8643         }
8644         ndr->depth--;
8645         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
8646         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8647         ndr->depth++;
8648         if (r->dependent_files) {
8649                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8650         }
8651         ndr->depth--;
8652         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
8653         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8654         ndr->depth++;
8655         if (r->previous_names) {
8656                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8657         }
8658         ndr->depth--;
8659         ndr->depth--;
8660 }
8661
8662 static enum ndr_err_code ndr_push_spoolss_DriverAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
8663 {
8664         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
8665         return NDR_ERR_SUCCESS;
8666 }
8667
8668 static enum ndr_err_code ndr_pull_spoolss_DriverAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
8669 {
8670         uint32_t v;
8671         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
8672         *r = v;
8673         return NDR_ERR_SUCCESS;
8674 }
8675
8676 _PUBLIC_ void ndr_print_spoolss_DriverAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
8677 {
8678         ndr_print_uint32(ndr, name, r);
8679         ndr->depth++;
8680         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_DRIVER_PACKAGE_AWARE", PRINTER_DRIVER_PACKAGE_AWARE, r);
8681         ndr->depth--;
8682 }
8683
8684 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
8685 {
8686         if (ndr_flags & NDR_SCALARS) {
8687                 NDR_CHECK(ndr_push_align(ndr, 8));
8688                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8689                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8690                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8691                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8692                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8693                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8694                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8695                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8696                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8697                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8698                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8700                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8701                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8702                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8703                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8704                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8705                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8706                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8707         }
8708         if (ndr_flags & NDR_BUFFERS) {
8709                 if (r->driver_name) {
8710                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8711                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8712                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8713                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8714                 }
8715                 if (r->architecture) {
8716                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8717                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8718                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8719                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8720                 }
8721                 if (r->driver_path) {
8722                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8725                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8726                 }
8727                 if (r->data_file) {
8728                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8729                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8731                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8732                 }
8733                 if (r->config_file) {
8734                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8735                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8736                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8737                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8738                 }
8739                 if (r->help_file) {
8740                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8741                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8742                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8743                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8744                 }
8745                 if (r->monitor_name) {
8746                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8748                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8749                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8750                 }
8751                 if (r->default_datatype) {
8752                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8753                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8754                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8755                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8756                 }
8757                 if (r->dependent_files) {
8758                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8759                 }
8760                 if (r->previous_names) {
8761                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8762                 }
8763                 if (r->manufacturer_name) {
8764                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8765                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8766                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8767                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8768                 }
8769                 if (r->manufacturer_url) {
8770                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8771                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8772                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8773                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8774                 }
8775                 if (r->hardware_id) {
8776                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8777                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8778                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8779                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8780                 }
8781                 if (r->provider) {
8782                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8783                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8784                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8785                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8786                 }
8787         }
8788         return NDR_ERR_SUCCESS;
8789 }
8790
8791 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
8792 {
8793         uint32_t _ptr_driver_name;
8794         TALLOC_CTX *_mem_save_driver_name_0;
8795         uint32_t _ptr_architecture;
8796         TALLOC_CTX *_mem_save_architecture_0;
8797         uint32_t _ptr_driver_path;
8798         TALLOC_CTX *_mem_save_driver_path_0;
8799         uint32_t _ptr_data_file;
8800         TALLOC_CTX *_mem_save_data_file_0;
8801         uint32_t _ptr_config_file;
8802         TALLOC_CTX *_mem_save_config_file_0;
8803         uint32_t _ptr_help_file;
8804         TALLOC_CTX *_mem_save_help_file_0;
8805         uint32_t _ptr_monitor_name;
8806         TALLOC_CTX *_mem_save_monitor_name_0;
8807         uint32_t _ptr_default_datatype;
8808         TALLOC_CTX *_mem_save_default_datatype_0;
8809         uint32_t _ptr_dependent_files;
8810         TALLOC_CTX *_mem_save_dependent_files_0;
8811         uint32_t _ptr_previous_names;
8812         TALLOC_CTX *_mem_save_previous_names_0;
8813         uint32_t _ptr_manufacturer_name;
8814         TALLOC_CTX *_mem_save_manufacturer_name_0;
8815         uint32_t _ptr_manufacturer_url;
8816         TALLOC_CTX *_mem_save_manufacturer_url_0;
8817         uint32_t _ptr_hardware_id;
8818         TALLOC_CTX *_mem_save_hardware_id_0;
8819         uint32_t _ptr_provider;
8820         TALLOC_CTX *_mem_save_provider_0;
8821         if (ndr_flags & NDR_SCALARS) {
8822                 NDR_CHECK(ndr_pull_align(ndr, 8));
8823                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8824                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8825                 if (_ptr_driver_name) {
8826                         NDR_PULL_ALLOC(ndr, r->driver_name);
8827                 } else {
8828                         r->driver_name = NULL;
8829                 }
8830                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8831                 if (_ptr_architecture) {
8832                         NDR_PULL_ALLOC(ndr, r->architecture);
8833                 } else {
8834                         r->architecture = NULL;
8835                 }
8836                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8837                 if (_ptr_driver_path) {
8838                         NDR_PULL_ALLOC(ndr, r->driver_path);
8839                 } else {
8840                         r->driver_path = NULL;
8841                 }
8842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8843                 if (_ptr_data_file) {
8844                         NDR_PULL_ALLOC(ndr, r->data_file);
8845                 } else {
8846                         r->data_file = NULL;
8847                 }
8848                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8849                 if (_ptr_config_file) {
8850                         NDR_PULL_ALLOC(ndr, r->config_file);
8851                 } else {
8852                         r->config_file = NULL;
8853                 }
8854                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8855                 if (_ptr_help_file) {
8856                         NDR_PULL_ALLOC(ndr, r->help_file);
8857                 } else {
8858                         r->help_file = NULL;
8859                 }
8860                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8861                 if (_ptr_monitor_name) {
8862                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8863                 } else {
8864                         r->monitor_name = NULL;
8865                 }
8866                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8867                 if (_ptr_default_datatype) {
8868                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8869                 } else {
8870                         r->default_datatype = NULL;
8871                 }
8872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8873                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8874                 if (_ptr_dependent_files) {
8875                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8876                 } else {
8877                         r->dependent_files = NULL;
8878                 }
8879                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8880                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8881                 if (_ptr_previous_names) {
8882                         NDR_PULL_ALLOC(ndr, r->previous_names);
8883                 } else {
8884                         r->previous_names = NULL;
8885                 }
8886                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
8887                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
8888                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
8889                 if (_ptr_manufacturer_name) {
8890                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
8891                 } else {
8892                         r->manufacturer_name = NULL;
8893                 }
8894                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
8895                 if (_ptr_manufacturer_url) {
8896                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
8897                 } else {
8898                         r->manufacturer_url = NULL;
8899                 }
8900                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
8901                 if (_ptr_hardware_id) {
8902                         NDR_PULL_ALLOC(ndr, r->hardware_id);
8903                 } else {
8904                         r->hardware_id = NULL;
8905                 }
8906                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
8907                 if (_ptr_provider) {
8908                         NDR_PULL_ALLOC(ndr, r->provider);
8909                 } else {
8910                         r->provider = NULL;
8911                 }
8912         }
8913         if (ndr_flags & NDR_BUFFERS) {
8914                 if (r->driver_name) {
8915                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8916                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8917                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8918                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8919                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8920                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8921                         }
8922                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8923                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8924                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8925                 }
8926                 if (r->architecture) {
8927                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8928                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8929                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8930                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8931                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8932                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8933                         }
8934                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8935                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8936                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8937                 }
8938                 if (r->driver_path) {
8939                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8940                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8941                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8942                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8943                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8944                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8945                         }
8946                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8947                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8948                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8949                 }
8950                 if (r->data_file) {
8951                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8952                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8953                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8954                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8955                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8956                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8957                         }
8958                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8959                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8960                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8961                 }
8962                 if (r->config_file) {
8963                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8964                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8965                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8966                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8967                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8968                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8969                         }
8970                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8971                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8972                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8973                 }
8974                 if (r->help_file) {
8975                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8976                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8977                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8978                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8979                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8980                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8981                         }
8982                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8983                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8984                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8985                 }
8986                 if (r->monitor_name) {
8987                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8988                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8989                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8990                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8991                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8992                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
8993                         }
8994                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8995                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8996                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8997                 }
8998                 if (r->default_datatype) {
8999                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9000                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9001                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9002                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9003                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9004                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
9005                         }
9006                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9007                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9008                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9009                 }
9010                 if (r->dependent_files) {
9011                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9012                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9013                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9015                 }
9016                 if (r->previous_names) {
9017                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9018                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9019                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9020                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9021                 }
9022                 if (r->manufacturer_name) {
9023                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9024                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9025                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9026                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9027                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9028                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
9029                         }
9030                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9031                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9032                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9033                 }
9034                 if (r->manufacturer_url) {
9035                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9036                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9037                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9038                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9039                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9040                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
9041                         }
9042                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9043                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9044                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9045                 }
9046                 if (r->hardware_id) {
9047                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9048                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9049                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9050                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9051                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9052                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
9053                         }
9054                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9055                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9056                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9057                 }
9058                 if (r->provider) {
9059                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9060                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9061                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9062                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9063                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9064                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
9065                         }
9066                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9067                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9068                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9069                 }
9070         }
9071         return NDR_ERR_SUCCESS;
9072 }
9073
9074 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
9075 {
9076         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
9077         ndr->depth++;
9078         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9079         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9080         ndr->depth++;
9081         if (r->driver_name) {
9082                 ndr_print_string(ndr, "driver_name", r->driver_name);
9083         }
9084         ndr->depth--;
9085         ndr_print_ptr(ndr, "architecture", r->architecture);
9086         ndr->depth++;
9087         if (r->architecture) {
9088                 ndr_print_string(ndr, "architecture", r->architecture);
9089         }
9090         ndr->depth--;
9091         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9092         ndr->depth++;
9093         if (r->driver_path) {
9094                 ndr_print_string(ndr, "driver_path", r->driver_path);
9095         }
9096         ndr->depth--;
9097         ndr_print_ptr(ndr, "data_file", r->data_file);
9098         ndr->depth++;
9099         if (r->data_file) {
9100                 ndr_print_string(ndr, "data_file", r->data_file);
9101         }
9102         ndr->depth--;
9103         ndr_print_ptr(ndr, "config_file", r->config_file);
9104         ndr->depth++;
9105         if (r->config_file) {
9106                 ndr_print_string(ndr, "config_file", r->config_file);
9107         }
9108         ndr->depth--;
9109         ndr_print_ptr(ndr, "help_file", r->help_file);
9110         ndr->depth++;
9111         if (r->help_file) {
9112                 ndr_print_string(ndr, "help_file", r->help_file);
9113         }
9114         ndr->depth--;
9115         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9116         ndr->depth++;
9117         if (r->monitor_name) {
9118                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9119         }
9120         ndr->depth--;
9121         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9122         ndr->depth++;
9123         if (r->default_datatype) {
9124                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9125         }
9126         ndr->depth--;
9127         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
9128         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9129         ndr->depth++;
9130         if (r->dependent_files) {
9131                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9132         }
9133         ndr->depth--;
9134         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
9135         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9136         ndr->depth++;
9137         if (r->previous_names) {
9138                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9139         }
9140         ndr->depth--;
9141         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9142         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9143         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9144         ndr->depth++;
9145         if (r->manufacturer_name) {
9146                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9147         }
9148         ndr->depth--;
9149         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9150         ndr->depth++;
9151         if (r->manufacturer_url) {
9152                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9153         }
9154         ndr->depth--;
9155         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9156         ndr->depth++;
9157         if (r->hardware_id) {
9158                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9159         }
9160         ndr->depth--;
9161         ndr_print_ptr(ndr, "provider", r->provider);
9162         ndr->depth++;
9163         if (r->provider) {
9164                 ndr_print_string(ndr, "provider", r->provider);
9165         }
9166         ndr->depth--;
9167         ndr->depth--;
9168 }
9169
9170 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
9171 {
9172         if (ndr_flags & NDR_SCALARS) {
9173                 NDR_CHECK(ndr_push_align(ndr, 8));
9174                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9175                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9176                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9177                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9178                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9179                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9180                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9181                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9182                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9183                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9184                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9185                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9186                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9187                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9188                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9189                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9190                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9191                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9192                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9193                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
9194                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
9195                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9196                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
9197                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
9198                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9199                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9200                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
9201                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9202                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9203         }
9204         if (ndr_flags & NDR_BUFFERS) {
9205                 if (r->driver_name) {
9206                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9207                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9208                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9209                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9210                 }
9211                 if (r->architecture) {
9212                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9213                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9214                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9215                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9216                 }
9217                 if (r->driver_path) {
9218                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9219                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9220                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9221                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9222                 }
9223                 if (r->data_file) {
9224                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9225                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9226                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9227                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9228                 }
9229                 if (r->config_file) {
9230                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9231                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9232                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9233                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9234                 }
9235                 if (r->help_file) {
9236                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9237                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9238                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9239                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9240                 }
9241                 if (r->monitor_name) {
9242                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9243                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9244                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9245                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9246                 }
9247                 if (r->default_datatype) {
9248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9249                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9250                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9251                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9252                 }
9253                 if (r->dependent_files) {
9254                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9255                 }
9256                 if (r->previous_names) {
9257                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9258                 }
9259                 if (r->manufacturer_name) {
9260                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9261                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9262                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9263                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9264                 }
9265                 if (r->manufacturer_url) {
9266                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9267                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9268                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9269                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9270                 }
9271                 if (r->hardware_id) {
9272                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9273                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9274                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9275                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9276                 }
9277                 if (r->provider) {
9278                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9279                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9280                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9281                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9282                 }
9283                 if (r->print_processor) {
9284                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9285                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9286                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9287                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9288                 }
9289                 if (r->vendor_setup) {
9290                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9291                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9292                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9293                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9294                 }
9295                 if (r->color_profiles) {
9296                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9297                 }
9298                 if (r->inf_path) {
9299                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9300                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9301                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9302                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9303                 }
9304                 if (r->core_driver_dependencies) {
9305                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9306                 }
9307         }
9308         return NDR_ERR_SUCCESS;
9309 }
9310
9311 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
9312 {
9313         uint32_t _ptr_driver_name;
9314         TALLOC_CTX *_mem_save_driver_name_0;
9315         uint32_t _ptr_architecture;
9316         TALLOC_CTX *_mem_save_architecture_0;
9317         uint32_t _ptr_driver_path;
9318         TALLOC_CTX *_mem_save_driver_path_0;
9319         uint32_t _ptr_data_file;
9320         TALLOC_CTX *_mem_save_data_file_0;
9321         uint32_t _ptr_config_file;
9322         TALLOC_CTX *_mem_save_config_file_0;
9323         uint32_t _ptr_help_file;
9324         TALLOC_CTX *_mem_save_help_file_0;
9325         uint32_t _ptr_monitor_name;
9326         TALLOC_CTX *_mem_save_monitor_name_0;
9327         uint32_t _ptr_default_datatype;
9328         TALLOC_CTX *_mem_save_default_datatype_0;
9329         uint32_t _ptr_dependent_files;
9330         TALLOC_CTX *_mem_save_dependent_files_0;
9331         uint32_t _ptr_previous_names;
9332         TALLOC_CTX *_mem_save_previous_names_0;
9333         uint32_t _ptr_manufacturer_name;
9334         TALLOC_CTX *_mem_save_manufacturer_name_0;
9335         uint32_t _ptr_manufacturer_url;
9336         TALLOC_CTX *_mem_save_manufacturer_url_0;
9337         uint32_t _ptr_hardware_id;
9338         TALLOC_CTX *_mem_save_hardware_id_0;
9339         uint32_t _ptr_provider;
9340         TALLOC_CTX *_mem_save_provider_0;
9341         uint32_t _ptr_print_processor;
9342         TALLOC_CTX *_mem_save_print_processor_0;
9343         uint32_t _ptr_vendor_setup;
9344         TALLOC_CTX *_mem_save_vendor_setup_0;
9345         uint32_t _ptr_color_profiles;
9346         TALLOC_CTX *_mem_save_color_profiles_0;
9347         uint32_t _ptr_inf_path;
9348         TALLOC_CTX *_mem_save_inf_path_0;
9349         uint32_t _ptr_core_driver_dependencies;
9350         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9351         if (ndr_flags & NDR_SCALARS) {
9352                 NDR_CHECK(ndr_pull_align(ndr, 8));
9353                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9354                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9355                 if (_ptr_driver_name) {
9356                         NDR_PULL_ALLOC(ndr, r->driver_name);
9357                 } else {
9358                         r->driver_name = NULL;
9359                 }
9360                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9361                 if (_ptr_architecture) {
9362                         NDR_PULL_ALLOC(ndr, r->architecture);
9363                 } else {
9364                         r->architecture = NULL;
9365                 }
9366                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9367                 if (_ptr_driver_path) {
9368                         NDR_PULL_ALLOC(ndr, r->driver_path);
9369                 } else {
9370                         r->driver_path = NULL;
9371                 }
9372                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9373                 if (_ptr_data_file) {
9374                         NDR_PULL_ALLOC(ndr, r->data_file);
9375                 } else {
9376                         r->data_file = NULL;
9377                 }
9378                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9379                 if (_ptr_config_file) {
9380                         NDR_PULL_ALLOC(ndr, r->config_file);
9381                 } else {
9382                         r->config_file = NULL;
9383                 }
9384                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9385                 if (_ptr_help_file) {
9386                         NDR_PULL_ALLOC(ndr, r->help_file);
9387                 } else {
9388                         r->help_file = NULL;
9389                 }
9390                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9391                 if (_ptr_monitor_name) {
9392                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9393                 } else {
9394                         r->monitor_name = NULL;
9395                 }
9396                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9397                 if (_ptr_default_datatype) {
9398                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9399                 } else {
9400                         r->default_datatype = NULL;
9401                 }
9402                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9403                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9404                 if (_ptr_dependent_files) {
9405                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9406                 } else {
9407                         r->dependent_files = NULL;
9408                 }
9409                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9410                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9411                 if (_ptr_previous_names) {
9412                         NDR_PULL_ALLOC(ndr, r->previous_names);
9413                 } else {
9414                         r->previous_names = NULL;
9415                 }
9416                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9417                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9418                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9419                 if (_ptr_manufacturer_name) {
9420                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9421                 } else {
9422                         r->manufacturer_name = NULL;
9423                 }
9424                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9425                 if (_ptr_manufacturer_url) {
9426                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9427                 } else {
9428                         r->manufacturer_url = NULL;
9429                 }
9430                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9431                 if (_ptr_hardware_id) {
9432                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9433                 } else {
9434                         r->hardware_id = NULL;
9435                 }
9436                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9437                 if (_ptr_provider) {
9438                         NDR_PULL_ALLOC(ndr, r->provider);
9439                 } else {
9440                         r->provider = NULL;
9441                 }
9442                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9443                 if (_ptr_print_processor) {
9444                         NDR_PULL_ALLOC(ndr, r->print_processor);
9445                 } else {
9446                         r->print_processor = NULL;
9447                 }
9448                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9449                 if (_ptr_vendor_setup) {
9450                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9451                 } else {
9452                         r->vendor_setup = NULL;
9453                 }
9454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9455                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9456                 if (_ptr_color_profiles) {
9457                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9458                 } else {
9459                         r->color_profiles = NULL;
9460                 }
9461                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9462                 if (_ptr_inf_path) {
9463                         NDR_PULL_ALLOC(ndr, r->inf_path);
9464                 } else {
9465                         r->inf_path = NULL;
9466                 }
9467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9468                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9469                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9470                 if (_ptr_core_driver_dependencies) {
9471                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9472                 } else {
9473                         r->core_driver_dependencies = NULL;
9474                 }
9475                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9476                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9477         }
9478         if (ndr_flags & NDR_BUFFERS) {
9479                 if (r->driver_name) {
9480                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9481                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9482                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9483                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9484                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9485                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
9486                         }
9487                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9488                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9489                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9490                 }
9491                 if (r->architecture) {
9492                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9493                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9494                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9495                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9496                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9497                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
9498                         }
9499                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9500                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9501                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9502                 }
9503                 if (r->driver_path) {
9504                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9505                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9506                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9507                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9508                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9509                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
9510                         }
9511                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9512                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9513                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9514                 }
9515                 if (r->data_file) {
9516                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9517                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9518                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9519                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9520                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9521                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
9522                         }
9523                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9524                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9525                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9526                 }
9527                 if (r->config_file) {
9528                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9529                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9530                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9531                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9532                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9533                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
9534                         }
9535                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9536                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9537                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9538                 }
9539                 if (r->help_file) {
9540                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9541                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9542                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9543                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9544                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9545                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
9546                         }
9547                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9548                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9549                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9550                 }
9551                 if (r->monitor_name) {
9552                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9553                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9554                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9555                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9556                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9557                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
9558                         }
9559                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9560                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9561                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9562                 }
9563                 if (r->default_datatype) {
9564                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9565                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9566                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9567                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9568                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9569                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
9570                         }
9571                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9572                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9573                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9574                 }
9575                 if (r->dependent_files) {
9576                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9577                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9578                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9579                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9580                 }
9581                 if (r->previous_names) {
9582                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9583                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9584                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9585                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9586                 }
9587                 if (r->manufacturer_name) {
9588                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9589                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9590                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9591                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9592                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9593                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
9594                         }
9595                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9596                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9597                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9598                 }
9599                 if (r->manufacturer_url) {
9600                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9601                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9602                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9603                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9604                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9605                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
9606                         }
9607                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9608                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9609                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9610                 }
9611                 if (r->hardware_id) {
9612                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9613                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9614                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9615                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9616                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9617                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
9618                         }
9619                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9620                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9621                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9622                 }
9623                 if (r->provider) {
9624                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9625                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9626                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9627                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9628                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9629                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
9630                         }
9631                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9632                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9633                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9634                 }
9635                 if (r->print_processor) {
9636                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
9637                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
9638                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
9639                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
9640                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
9641                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
9642                         }
9643                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
9644                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
9645                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
9646                 }
9647                 if (r->vendor_setup) {
9648                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
9649                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
9650                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
9651                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
9652                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
9653                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->vendor_setup), ndr_get_array_length(ndr, &r->vendor_setup));
9654                         }
9655                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
9656                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
9657                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
9658                 }
9659                 if (r->color_profiles) {
9660                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
9661                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
9662                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9663                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
9664                 }
9665                 if (r->inf_path) {
9666                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9667                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
9668                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
9669                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
9670                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
9671                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->inf_path), ndr_get_array_length(ndr, &r->inf_path));
9672                         }
9673                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
9674                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
9675                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
9676                 }
9677                 if (r->core_driver_dependencies) {
9678                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
9679                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
9680                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9681                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
9682                 }
9683         }
9684         return NDR_ERR_SUCCESS;
9685 }
9686
9687 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
9688 {
9689         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
9690         ndr->depth++;
9691         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9692         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9693         ndr->depth++;
9694         if (r->driver_name) {
9695                 ndr_print_string(ndr, "driver_name", r->driver_name);
9696         }
9697         ndr->depth--;
9698         ndr_print_ptr(ndr, "architecture", r->architecture);
9699         ndr->depth++;
9700         if (r->architecture) {
9701                 ndr_print_string(ndr, "architecture", r->architecture);
9702         }
9703         ndr->depth--;
9704         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9705         ndr->depth++;
9706         if (r->driver_path) {
9707                 ndr_print_string(ndr, "driver_path", r->driver_path);
9708         }
9709         ndr->depth--;
9710         ndr_print_ptr(ndr, "data_file", r->data_file);
9711         ndr->depth++;
9712         if (r->data_file) {
9713                 ndr_print_string(ndr, "data_file", r->data_file);
9714         }
9715         ndr->depth--;
9716         ndr_print_ptr(ndr, "config_file", r->config_file);
9717         ndr->depth++;
9718         if (r->config_file) {
9719                 ndr_print_string(ndr, "config_file", r->config_file);
9720         }
9721         ndr->depth--;
9722         ndr_print_ptr(ndr, "help_file", r->help_file);
9723         ndr->depth++;
9724         if (r->help_file) {
9725                 ndr_print_string(ndr, "help_file", r->help_file);
9726         }
9727         ndr->depth--;
9728         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9729         ndr->depth++;
9730         if (r->monitor_name) {
9731                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9732         }
9733         ndr->depth--;
9734         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9735         ndr->depth++;
9736         if (r->default_datatype) {
9737                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9738         }
9739         ndr->depth--;
9740         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
9741         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9742         ndr->depth++;
9743         if (r->dependent_files) {
9744                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9745         }
9746         ndr->depth--;
9747         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
9748         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9749         ndr->depth++;
9750         if (r->previous_names) {
9751                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9752         }
9753         ndr->depth--;
9754         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9755         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9756         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9757         ndr->depth++;
9758         if (r->manufacturer_name) {
9759                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9760         }
9761         ndr->depth--;
9762         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9763         ndr->depth++;
9764         if (r->manufacturer_url) {
9765                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9766         }
9767         ndr->depth--;
9768         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9769         ndr->depth++;
9770         if (r->hardware_id) {
9771                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9772         }
9773         ndr->depth--;
9774         ndr_print_ptr(ndr, "provider", r->provider);
9775         ndr->depth++;
9776         if (r->provider) {
9777                 ndr_print_string(ndr, "provider", r->provider);
9778         }
9779         ndr->depth--;
9780         ndr_print_ptr(ndr, "print_processor", r->print_processor);
9781         ndr->depth++;
9782         if (r->print_processor) {
9783                 ndr_print_string(ndr, "print_processor", r->print_processor);
9784         }
9785         ndr->depth--;
9786         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
9787         ndr->depth++;
9788         if (r->vendor_setup) {
9789                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
9790         }
9791         ndr->depth--;
9792         ndr_print_uint32(ndr, "_ndr_size_color_profiles", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_color_profiles);
9793         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
9794         ndr->depth++;
9795         if (r->color_profiles) {
9796                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
9797         }
9798         ndr->depth--;
9799         ndr_print_ptr(ndr, "inf_path", r->inf_path);
9800         ndr->depth++;
9801         if (r->inf_path) {
9802                 ndr_print_string(ndr, "inf_path", r->inf_path);
9803         }
9804         ndr->depth--;
9805         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
9806         ndr_print_uint32(ndr, "_ndr_size_core_driver_dependencies", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_core_driver_dependencies);
9807         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9808         ndr->depth++;
9809         if (r->core_driver_dependencies) {
9810                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9811         }
9812         ndr->depth--;
9813         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
9814         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
9815         ndr->depth--;
9816 }
9817
9818 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
9819 {
9820         if (ndr_flags & NDR_SCALARS) {
9821                 int level = ndr_push_get_switch_value(ndr, r);
9822                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9823                 switch (level) {
9824                         case 1: {
9825                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
9826                         break; }
9827
9828                         case 2: {
9829                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
9830                         break; }
9831
9832                         case 3: {
9833                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
9834                         break; }
9835
9836                         case 4: {
9837                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
9838                         break; }
9839
9840                         case 6: {
9841                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
9842                         break; }
9843
9844                         case 8: {
9845                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
9846                         break; }
9847
9848                         default:
9849                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9850                 }
9851         }
9852         if (ndr_flags & NDR_BUFFERS) {
9853                 int level = ndr_push_get_switch_value(ndr, r);
9854                 switch (level) {
9855                         case 1:
9856                                 if (r->info1) {
9857                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9858                                 }
9859                         break;
9860
9861                         case 2:
9862                                 if (r->info2) {
9863                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9864                                 }
9865                         break;
9866
9867                         case 3:
9868                                 if (r->info3) {
9869                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9870                                 }
9871                         break;
9872
9873                         case 4:
9874                                 if (r->info4) {
9875                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9876                                 }
9877                         break;
9878
9879                         case 6:
9880                                 if (r->info6) {
9881                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9882                                 }
9883                         break;
9884
9885                         case 8:
9886                                 if (r->info8) {
9887                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9888                                 }
9889                         break;
9890
9891                         default:
9892                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9893                 }
9894         }
9895         return NDR_ERR_SUCCESS;
9896 }
9897
9898 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
9899 {
9900         int level;
9901         uint32_t _level;
9902         TALLOC_CTX *_mem_save_info1_0;
9903         TALLOC_CTX *_mem_save_info2_0;
9904         TALLOC_CTX *_mem_save_info3_0;
9905         TALLOC_CTX *_mem_save_info4_0;
9906         TALLOC_CTX *_mem_save_info6_0;
9907         TALLOC_CTX *_mem_save_info8_0;
9908         level = ndr_pull_get_switch_value(ndr, r);
9909         if (ndr_flags & NDR_SCALARS) {
9910                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9911                 if (_level != level) {
9912                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
9913                 }
9914                 switch (level) {
9915                         case 1: {
9916                                 uint32_t _ptr_info1;
9917                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
9918                                 if (_ptr_info1) {
9919                                         NDR_PULL_ALLOC(ndr, r->info1);
9920                                 } else {
9921                                         r->info1 = NULL;
9922                                 }
9923                         break; }
9924
9925                         case 2: {
9926                                 uint32_t _ptr_info2;
9927                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
9928                                 if (_ptr_info2) {
9929                                         NDR_PULL_ALLOC(ndr, r->info2);
9930                                 } else {
9931                                         r->info2 = NULL;
9932                                 }
9933                         break; }
9934
9935                         case 3: {
9936                                 uint32_t _ptr_info3;
9937                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
9938                                 if (_ptr_info3) {
9939                                         NDR_PULL_ALLOC(ndr, r->info3);
9940                                 } else {
9941                                         r->info3 = NULL;
9942                                 }
9943                         break; }
9944
9945                         case 4: {
9946                                 uint32_t _ptr_info4;
9947                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
9948                                 if (_ptr_info4) {
9949                                         NDR_PULL_ALLOC(ndr, r->info4);
9950                                 } else {
9951                                         r->info4 = NULL;
9952                                 }
9953                         break; }
9954
9955                         case 6: {
9956                                 uint32_t _ptr_info6;
9957                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
9958                                 if (_ptr_info6) {
9959                                         NDR_PULL_ALLOC(ndr, r->info6);
9960                                 } else {
9961                                         r->info6 = NULL;
9962                                 }
9963                         break; }
9964
9965                         case 8: {
9966                                 uint32_t _ptr_info8;
9967                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
9968                                 if (_ptr_info8) {
9969                                         NDR_PULL_ALLOC(ndr, r->info8);
9970                                 } else {
9971                                         r->info8 = NULL;
9972                                 }
9973                         break; }
9974
9975                         default:
9976                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9977                 }
9978         }
9979         if (ndr_flags & NDR_BUFFERS) {
9980                 switch (level) {
9981                         case 1:
9982                                 if (r->info1) {
9983                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9984                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
9985                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9986                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
9987                                 }
9988                         break;
9989
9990                         case 2:
9991                                 if (r->info2) {
9992                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9993                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
9994                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9995                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
9996                                 }
9997                         break;
9998
9999                         case 3:
10000                                 if (r->info3) {
10001                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
10002                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
10003                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10004                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
10005                                 }
10006                         break;
10007
10008                         case 4:
10009                                 if (r->info4) {
10010                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
10011                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
10012                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10013                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
10014                                 }
10015                         break;
10016
10017                         case 6:
10018                                 if (r->info6) {
10019                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
10020                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
10021                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10022                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
10023                                 }
10024                         break;
10025
10026                         case 8:
10027                                 if (r->info8) {
10028                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
10029                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
10030                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10031                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
10032                                 }
10033                         break;
10034
10035                         default:
10036                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
10037                 }
10038         }
10039         return NDR_ERR_SUCCESS;
10040 }
10041
10042 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
10043 {
10044         int level;
10045         level = ndr_print_get_switch_value(ndr, r);
10046         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
10047         switch (level) {
10048                 case 1:
10049                         ndr_print_ptr(ndr, "info1", r->info1);
10050                         ndr->depth++;
10051                         if (r->info1) {
10052                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
10053                         }
10054                         ndr->depth--;
10055                 break;
10056
10057                 case 2:
10058                         ndr_print_ptr(ndr, "info2", r->info2);
10059                         ndr->depth++;
10060                         if (r->info2) {
10061                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
10062                         }
10063                         ndr->depth--;
10064                 break;
10065
10066                 case 3:
10067                         ndr_print_ptr(ndr, "info3", r->info3);
10068                         ndr->depth++;
10069                         if (r->info3) {
10070                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
10071                         }
10072                         ndr->depth--;
10073                 break;
10074
10075                 case 4:
10076                         ndr_print_ptr(ndr, "info4", r->info4);
10077                         ndr->depth++;
10078                         if (r->info4) {
10079                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
10080                         }
10081                         ndr->depth--;
10082                 break;
10083
10084                 case 6:
10085                         ndr_print_ptr(ndr, "info6", r->info6);
10086                         ndr->depth++;
10087                         if (r->info6) {
10088                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
10089                         }
10090                         ndr->depth--;
10091                 break;
10092
10093                 case 8:
10094                         ndr_print_ptr(ndr, "info8", r->info8);
10095                         ndr->depth++;
10096                         if (r->info8) {
10097                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
10098                         }
10099                         ndr->depth--;
10100                 break;
10101
10102                 default:
10103                         ndr_print_bad_level(ndr, name, level);
10104         }
10105 }
10106
10107 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
10108 {
10109         if (ndr_flags & NDR_SCALARS) {
10110                 NDR_CHECK(ndr_push_align(ndr, 4));
10111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
10112                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
10113                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10114         }
10115         if (ndr_flags & NDR_BUFFERS) {
10116                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10117         }
10118         return NDR_ERR_SUCCESS;
10119 }
10120
10121 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
10122 {
10123         if (ndr_flags & NDR_SCALARS) {
10124                 NDR_CHECK(ndr_pull_align(ndr, 4));
10125                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
10126                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
10127                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10128         }
10129         if (ndr_flags & NDR_BUFFERS) {
10130                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10131         }
10132         return NDR_ERR_SUCCESS;
10133 }
10134
10135 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
10136 {
10137         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
10138         ndr->depth++;
10139         ndr_print_uint32(ndr, "level", r->level);
10140         ndr_print_set_switch_value(ndr, &r->info, r->level);
10141         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
10142         ndr->depth--;
10143 }
10144
10145 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
10146 {
10147         if (ndr_flags & NDR_SCALARS) {
10148                 NDR_CHECK(ndr_push_align(ndr, 4));
10149                 {
10150                         uint32_t _flags_save_string = ndr->flags;
10151                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10152                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10153                         ndr->flags = _flags_save_string;
10154                 }
10155         }
10156         if (ndr_flags & NDR_BUFFERS) {
10157                 {
10158                         uint32_t _flags_save_string = ndr->flags;
10159                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10160                         if (r->driver_name) {
10161                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
10162                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10163                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
10164                         }
10165                         ndr->flags = _flags_save_string;
10166                 }
10167         }
10168         return NDR_ERR_SUCCESS;
10169 }
10170
10171 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
10172 {
10173         uint32_t _ptr_driver_name;
10174         TALLOC_CTX *_mem_save_driver_name_0;
10175         if (ndr_flags & NDR_SCALARS) {
10176                 NDR_CHECK(ndr_pull_align(ndr, 4));
10177                 {
10178                         uint32_t _flags_save_string = ndr->flags;
10179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10180                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10181                         if (_ptr_driver_name) {
10182                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10183                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10184                         } else {
10185                                 r->driver_name = NULL;
10186                         }
10187                         ndr->flags = _flags_save_string;
10188                 }
10189         }
10190         if (ndr_flags & NDR_BUFFERS) {
10191                 {
10192                         uint32_t _flags_save_string = ndr->flags;
10193                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10194                         if (r->driver_name) {
10195                                 uint32_t _relative_save_offset;
10196                                 _relative_save_offset = ndr->offset;
10197                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10198                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10199                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10200                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10201                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10202                                 ndr->offset = _relative_save_offset;
10203                         }
10204                         ndr->flags = _flags_save_string;
10205                 }
10206         }
10207         return NDR_ERR_SUCCESS;
10208 }
10209
10210 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
10211 {
10212         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
10213         ndr->depth++;
10214         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10215         ndr->depth++;
10216         if (r->driver_name) {
10217                 ndr_print_string(ndr, "driver_name", r->driver_name);
10218         }
10219         ndr->depth--;
10220         ndr->depth--;
10221 }
10222
10223 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
10224 {
10225         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
10226 }
10227
10228 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
10229 {
10230         if (ndr_flags & NDR_SCALARS) {
10231                 NDR_CHECK(ndr_push_align(ndr, 4));
10232                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10233                 {
10234                         uint32_t _flags_save_string = ndr->flags;
10235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10236                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10237                         ndr->flags = _flags_save_string;
10238                 }
10239                 {
10240                         uint32_t _flags_save_string = ndr->flags;
10241                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10242                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10243                         ndr->flags = _flags_save_string;
10244                 }
10245                 {
10246                         uint32_t _flags_save_string = ndr->flags;
10247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10248                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10249                         ndr->flags = _flags_save_string;
10250                 }
10251                 {
10252                         uint32_t _flags_save_string = ndr->flags;
10253                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10254                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10255                         ndr->flags = _flags_save_string;
10256                 }
10257                 {
10258                         uint32_t _flags_save_string = ndr->flags;
10259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10260                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10261                         ndr->flags = _flags_save_string;
10262                 }
10263         }
10264         if (ndr_flags & NDR_BUFFERS) {
10265                 {
10266                         uint32_t _flags_save_string = ndr->flags;
10267                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10268                         if (r->driver_name) {
10269                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
10270                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10271                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
10272                         }
10273                         ndr->flags = _flags_save_string;
10274                 }
10275                 {
10276                         uint32_t _flags_save_string = ndr->flags;
10277                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10278                         if (r->architecture) {
10279                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
10280                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10281                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
10282                         }
10283                         ndr->flags = _flags_save_string;
10284                 }
10285                 {
10286                         uint32_t _flags_save_string = ndr->flags;
10287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10288                         if (r->driver_path) {
10289                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
10290                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10291                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
10292                         }
10293                         ndr->flags = _flags_save_string;
10294                 }
10295                 {
10296                         uint32_t _flags_save_string = ndr->flags;
10297                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10298                         if (r->data_file) {
10299                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
10300                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10301                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
10302                         }
10303                         ndr->flags = _flags_save_string;
10304                 }
10305                 {
10306                         uint32_t _flags_save_string = ndr->flags;
10307                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10308                         if (r->config_file) {
10309                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
10310                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10311                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
10312                         }
10313                         ndr->flags = _flags_save_string;
10314                 }
10315         }
10316         return NDR_ERR_SUCCESS;
10317 }
10318
10319 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
10320 {
10321         uint32_t _ptr_driver_name;
10322         TALLOC_CTX *_mem_save_driver_name_0;
10323         uint32_t _ptr_architecture;
10324         TALLOC_CTX *_mem_save_architecture_0;
10325         uint32_t _ptr_driver_path;
10326         TALLOC_CTX *_mem_save_driver_path_0;
10327         uint32_t _ptr_data_file;
10328         TALLOC_CTX *_mem_save_data_file_0;
10329         uint32_t _ptr_config_file;
10330         TALLOC_CTX *_mem_save_config_file_0;
10331         if (ndr_flags & NDR_SCALARS) {
10332                 NDR_CHECK(ndr_pull_align(ndr, 4));
10333                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10334                 {
10335                         uint32_t _flags_save_string = ndr->flags;
10336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10337                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10338                         if (_ptr_driver_name) {
10339                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10340                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10341                         } else {
10342                                 r->driver_name = NULL;
10343                         }
10344                         ndr->flags = _flags_save_string;
10345                 }
10346                 {
10347                         uint32_t _flags_save_string = ndr->flags;
10348                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10349                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10350                         if (_ptr_architecture) {
10351                                 NDR_PULL_ALLOC(ndr, r->architecture);
10352                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10353                         } else {
10354                                 r->architecture = NULL;
10355                         }
10356                         ndr->flags = _flags_save_string;
10357                 }
10358                 {
10359                         uint32_t _flags_save_string = ndr->flags;
10360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10361                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10362                         if (_ptr_driver_path) {
10363                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10364                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10365                         } else {
10366                                 r->driver_path = NULL;
10367                         }
10368                         ndr->flags = _flags_save_string;
10369                 }
10370                 {
10371                         uint32_t _flags_save_string = ndr->flags;
10372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10373                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10374                         if (_ptr_data_file) {
10375                                 NDR_PULL_ALLOC(ndr, r->data_file);
10376                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10377                         } else {
10378                                 r->data_file = NULL;
10379                         }
10380                         ndr->flags = _flags_save_string;
10381                 }
10382                 {
10383                         uint32_t _flags_save_string = ndr->flags;
10384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10385                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10386                         if (_ptr_config_file) {
10387                                 NDR_PULL_ALLOC(ndr, r->config_file);
10388                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10389                         } else {
10390                                 r->config_file = NULL;
10391                         }
10392                         ndr->flags = _flags_save_string;
10393                 }
10394         }
10395         if (ndr_flags & NDR_BUFFERS) {
10396                 {
10397                         uint32_t _flags_save_string = ndr->flags;
10398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10399                         if (r->driver_name) {
10400                                 uint32_t _relative_save_offset;
10401                                 _relative_save_offset = ndr->offset;
10402                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10403                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10404                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10405                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10406                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10407                                 ndr->offset = _relative_save_offset;
10408                         }
10409                         ndr->flags = _flags_save_string;
10410                 }
10411                 {
10412                         uint32_t _flags_save_string = ndr->flags;
10413                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10414                         if (r->architecture) {
10415                                 uint32_t _relative_save_offset;
10416                                 _relative_save_offset = ndr->offset;
10417                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10418                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10419                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10420                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10421                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10422                                 ndr->offset = _relative_save_offset;
10423                         }
10424                         ndr->flags = _flags_save_string;
10425                 }
10426                 {
10427                         uint32_t _flags_save_string = ndr->flags;
10428                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10429                         if (r->driver_path) {
10430                                 uint32_t _relative_save_offset;
10431                                 _relative_save_offset = ndr->offset;
10432                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10433                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10434                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10435                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10436                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10437                                 ndr->offset = _relative_save_offset;
10438                         }
10439                         ndr->flags = _flags_save_string;
10440                 }
10441                 {
10442                         uint32_t _flags_save_string = ndr->flags;
10443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10444                         if (r->data_file) {
10445                                 uint32_t _relative_save_offset;
10446                                 _relative_save_offset = ndr->offset;
10447                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10448                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10449                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10450                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10451                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10452                                 ndr->offset = _relative_save_offset;
10453                         }
10454                         ndr->flags = _flags_save_string;
10455                 }
10456                 {
10457                         uint32_t _flags_save_string = ndr->flags;
10458                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10459                         if (r->config_file) {
10460                                 uint32_t _relative_save_offset;
10461                                 _relative_save_offset = ndr->offset;
10462                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10463                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10464                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10465                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10466                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10467                                 ndr->offset = _relative_save_offset;
10468                         }
10469                         ndr->flags = _flags_save_string;
10470                 }
10471         }
10472         return NDR_ERR_SUCCESS;
10473 }
10474
10475 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10476 {
10477         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10478         ndr->depth++;
10479         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10480         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10481         ndr->depth++;
10482         if (r->driver_name) {
10483                 ndr_print_string(ndr, "driver_name", r->driver_name);
10484         }
10485         ndr->depth--;
10486         ndr_print_ptr(ndr, "architecture", r->architecture);
10487         ndr->depth++;
10488         if (r->architecture) {
10489                 ndr_print_string(ndr, "architecture", r->architecture);
10490         }
10491         ndr->depth--;
10492         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10493         ndr->depth++;
10494         if (r->driver_path) {
10495                 ndr_print_string(ndr, "driver_path", r->driver_path);
10496         }
10497         ndr->depth--;
10498         ndr_print_ptr(ndr, "data_file", r->data_file);
10499         ndr->depth++;
10500         if (r->data_file) {
10501                 ndr_print_string(ndr, "data_file", r->data_file);
10502         }
10503         ndr->depth--;
10504         ndr_print_ptr(ndr, "config_file", r->config_file);
10505         ndr->depth++;
10506         if (r->config_file) {
10507                 ndr_print_string(ndr, "config_file", r->config_file);
10508         }
10509         ndr->depth--;
10510         ndr->depth--;
10511 }
10512
10513 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10514 {
10515         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10516 }
10517
10518 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10519 {
10520         if (ndr_flags & NDR_SCALARS) {
10521                 NDR_CHECK(ndr_push_align(ndr, 4));
10522                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10523                 {
10524                         uint32_t _flags_save_string = ndr->flags;
10525                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10526                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10527                         ndr->flags = _flags_save_string;
10528                 }
10529                 {
10530                         uint32_t _flags_save_string = ndr->flags;
10531                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10532                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10533                         ndr->flags = _flags_save_string;
10534                 }
10535                 {
10536                         uint32_t _flags_save_string = ndr->flags;
10537                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10538                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10539                         ndr->flags = _flags_save_string;
10540                 }
10541                 {
10542                         uint32_t _flags_save_string = ndr->flags;
10543                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10544                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10545                         ndr->flags = _flags_save_string;
10546                 }
10547                 {
10548                         uint32_t _flags_save_string = ndr->flags;
10549                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10550                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10551                         ndr->flags = _flags_save_string;
10552                 }
10553                 {
10554                         uint32_t _flags_save_string = ndr->flags;
10555                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10556                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10557                         ndr->flags = _flags_save_string;
10558                 }
10559                 {
10560                         uint32_t _flags_save_string_array = ndr->flags;
10561                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10562                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10563                         ndr->flags = _flags_save_string_array;
10564                 }
10565                 {
10566                         uint32_t _flags_save_string = ndr->flags;
10567                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10568                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10569                         ndr->flags = _flags_save_string;
10570                 }
10571                 {
10572                         uint32_t _flags_save_string = ndr->flags;
10573                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10574                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10575                         ndr->flags = _flags_save_string;
10576                 }
10577         }
10578         if (ndr_flags & NDR_BUFFERS) {
10579                 {
10580                         uint32_t _flags_save_string = ndr->flags;
10581                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10582                         if (r->driver_name) {
10583                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
10584                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10585                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
10586                         }
10587                         ndr->flags = _flags_save_string;
10588                 }
10589                 {
10590                         uint32_t _flags_save_string = ndr->flags;
10591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10592                         if (r->architecture) {
10593                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
10594                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10595                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
10596                         }
10597                         ndr->flags = _flags_save_string;
10598                 }
10599                 {
10600                         uint32_t _flags_save_string = ndr->flags;
10601                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10602                         if (r->driver_path) {
10603                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
10604                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10605                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
10606                         }
10607                         ndr->flags = _flags_save_string;
10608                 }
10609                 {
10610                         uint32_t _flags_save_string = ndr->flags;
10611                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10612                         if (r->data_file) {
10613                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
10614                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10615                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
10616                         }
10617                         ndr->flags = _flags_save_string;
10618                 }
10619                 {
10620                         uint32_t _flags_save_string = ndr->flags;
10621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10622                         if (r->config_file) {
10623                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
10624                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10625                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
10626                         }
10627                         ndr->flags = _flags_save_string;
10628                 }
10629                 {
10630                         uint32_t _flags_save_string = ndr->flags;
10631                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10632                         if (r->help_file) {
10633                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
10634                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10635                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
10636                         }
10637                         ndr->flags = _flags_save_string;
10638                 }
10639                 {
10640                         uint32_t _flags_save_string_array = ndr->flags;
10641                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10642                         if (r->dependent_files) {
10643                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
10644                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10645                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
10646                         }
10647                         ndr->flags = _flags_save_string_array;
10648                 }
10649                 {
10650                         uint32_t _flags_save_string = ndr->flags;
10651                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10652                         if (r->monitor_name) {
10653                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
10654                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10655                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
10656                         }
10657                         ndr->flags = _flags_save_string;
10658                 }
10659                 {
10660                         uint32_t _flags_save_string = ndr->flags;
10661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10662                         if (r->default_datatype) {
10663                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
10664                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10665                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
10666                         }
10667                         ndr->flags = _flags_save_string;
10668                 }
10669         }
10670         return NDR_ERR_SUCCESS;
10671 }
10672
10673 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
10674 {
10675         uint32_t _ptr_driver_name;
10676         TALLOC_CTX *_mem_save_driver_name_0;
10677         uint32_t _ptr_architecture;
10678         TALLOC_CTX *_mem_save_architecture_0;
10679         uint32_t _ptr_driver_path;
10680         TALLOC_CTX *_mem_save_driver_path_0;
10681         uint32_t _ptr_data_file;
10682         TALLOC_CTX *_mem_save_data_file_0;
10683         uint32_t _ptr_config_file;
10684         TALLOC_CTX *_mem_save_config_file_0;
10685         uint32_t _ptr_help_file;
10686         TALLOC_CTX *_mem_save_help_file_0;
10687         uint32_t _ptr_dependent_files;
10688         TALLOC_CTX *_mem_save_dependent_files_0;
10689         uint32_t _ptr_monitor_name;
10690         TALLOC_CTX *_mem_save_monitor_name_0;
10691         uint32_t _ptr_default_datatype;
10692         TALLOC_CTX *_mem_save_default_datatype_0;
10693         if (ndr_flags & NDR_SCALARS) {
10694                 NDR_CHECK(ndr_pull_align(ndr, 4));
10695                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10696                 {
10697                         uint32_t _flags_save_string = ndr->flags;
10698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10699                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10700                         if (_ptr_driver_name) {
10701                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10702                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10703                         } else {
10704                                 r->driver_name = NULL;
10705                         }
10706                         ndr->flags = _flags_save_string;
10707                 }
10708                 {
10709                         uint32_t _flags_save_string = ndr->flags;
10710                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10711                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10712                         if (_ptr_architecture) {
10713                                 NDR_PULL_ALLOC(ndr, r->architecture);
10714                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10715                         } else {
10716                                 r->architecture = NULL;
10717                         }
10718                         ndr->flags = _flags_save_string;
10719                 }
10720                 {
10721                         uint32_t _flags_save_string = ndr->flags;
10722                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10723                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10724                         if (_ptr_driver_path) {
10725                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10726                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10727                         } else {
10728                                 r->driver_path = NULL;
10729                         }
10730                         ndr->flags = _flags_save_string;
10731                 }
10732                 {
10733                         uint32_t _flags_save_string = ndr->flags;
10734                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10735                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10736                         if (_ptr_data_file) {
10737                                 NDR_PULL_ALLOC(ndr, r->data_file);
10738                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10739                         } else {
10740                                 r->data_file = NULL;
10741                         }
10742                         ndr->flags = _flags_save_string;
10743                 }
10744                 {
10745                         uint32_t _flags_save_string = ndr->flags;
10746                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10747                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10748                         if (_ptr_config_file) {
10749                                 NDR_PULL_ALLOC(ndr, r->config_file);
10750                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10751                         } else {
10752                                 r->config_file = NULL;
10753                         }
10754                         ndr->flags = _flags_save_string;
10755                 }
10756                 {
10757                         uint32_t _flags_save_string = ndr->flags;
10758                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10759                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10760                         if (_ptr_help_file) {
10761                                 NDR_PULL_ALLOC(ndr, r->help_file);
10762                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10763                         } else {
10764                                 r->help_file = NULL;
10765                         }
10766                         ndr->flags = _flags_save_string;
10767                 }
10768                 {
10769                         uint32_t _flags_save_string_array = ndr->flags;
10770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10771                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10772                         if (_ptr_dependent_files) {
10773                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10774                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10775                         } else {
10776                                 r->dependent_files = NULL;
10777                         }
10778                         ndr->flags = _flags_save_string_array;
10779                 }
10780                 {
10781                         uint32_t _flags_save_string = ndr->flags;
10782                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10783                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10784                         if (_ptr_monitor_name) {
10785                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10786                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10787                         } else {
10788                                 r->monitor_name = NULL;
10789                         }
10790                         ndr->flags = _flags_save_string;
10791                 }
10792                 {
10793                         uint32_t _flags_save_string = ndr->flags;
10794                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10795                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10796                         if (_ptr_default_datatype) {
10797                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10798                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10799                         } else {
10800                                 r->default_datatype = NULL;
10801                         }
10802                         ndr->flags = _flags_save_string;
10803                 }
10804         }
10805         if (ndr_flags & NDR_BUFFERS) {
10806                 {
10807                         uint32_t _flags_save_string = ndr->flags;
10808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10809                         if (r->driver_name) {
10810                                 uint32_t _relative_save_offset;
10811                                 _relative_save_offset = ndr->offset;
10812                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10813                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10814                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10815                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10816                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10817                                 ndr->offset = _relative_save_offset;
10818                         }
10819                         ndr->flags = _flags_save_string;
10820                 }
10821                 {
10822                         uint32_t _flags_save_string = ndr->flags;
10823                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10824                         if (r->architecture) {
10825                                 uint32_t _relative_save_offset;
10826                                 _relative_save_offset = ndr->offset;
10827                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10828                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10829                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10830                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10831                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10832                                 ndr->offset = _relative_save_offset;
10833                         }
10834                         ndr->flags = _flags_save_string;
10835                 }
10836                 {
10837                         uint32_t _flags_save_string = ndr->flags;
10838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10839                         if (r->driver_path) {
10840                                 uint32_t _relative_save_offset;
10841                                 _relative_save_offset = ndr->offset;
10842                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10843                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10844                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10845                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10846                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10847                                 ndr->offset = _relative_save_offset;
10848                         }
10849                         ndr->flags = _flags_save_string;
10850                 }
10851                 {
10852                         uint32_t _flags_save_string = ndr->flags;
10853                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10854                         if (r->data_file) {
10855                                 uint32_t _relative_save_offset;
10856                                 _relative_save_offset = ndr->offset;
10857                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10858                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10859                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10860                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10861                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10862                                 ndr->offset = _relative_save_offset;
10863                         }
10864                         ndr->flags = _flags_save_string;
10865                 }
10866                 {
10867                         uint32_t _flags_save_string = ndr->flags;
10868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10869                         if (r->config_file) {
10870                                 uint32_t _relative_save_offset;
10871                                 _relative_save_offset = ndr->offset;
10872                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10873                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10874                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10875                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10876                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10877                                 ndr->offset = _relative_save_offset;
10878                         }
10879                         ndr->flags = _flags_save_string;
10880                 }
10881                 {
10882                         uint32_t _flags_save_string = ndr->flags;
10883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10884                         if (r->help_file) {
10885                                 uint32_t _relative_save_offset;
10886                                 _relative_save_offset = ndr->offset;
10887                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10888                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10889                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10890                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10891                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10892                                 ndr->offset = _relative_save_offset;
10893                         }
10894                         ndr->flags = _flags_save_string;
10895                 }
10896                 {
10897                         uint32_t _flags_save_string_array = ndr->flags;
10898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10899                         if (r->dependent_files) {
10900                                 uint32_t _relative_save_offset;
10901                                 _relative_save_offset = ndr->offset;
10902                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10903                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10904                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10905                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
10906                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10907                                 ndr->offset = _relative_save_offset;
10908                         }
10909                         ndr->flags = _flags_save_string_array;
10910                 }
10911                 {
10912                         uint32_t _flags_save_string = ndr->flags;
10913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10914                         if (r->monitor_name) {
10915                                 uint32_t _relative_save_offset;
10916                                 _relative_save_offset = ndr->offset;
10917                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10918                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10919                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10920                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10921                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10922                                 ndr->offset = _relative_save_offset;
10923                         }
10924                         ndr->flags = _flags_save_string;
10925                 }
10926                 {
10927                         uint32_t _flags_save_string = ndr->flags;
10928                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10929                         if (r->default_datatype) {
10930                                 uint32_t _relative_save_offset;
10931                                 _relative_save_offset = ndr->offset;
10932                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
10933                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10934                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10935                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
10936                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10937                                 ndr->offset = _relative_save_offset;
10938                         }
10939                         ndr->flags = _flags_save_string;
10940                 }
10941         }
10942         return NDR_ERR_SUCCESS;
10943 }
10944
10945 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
10946 {
10947         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
10948         ndr->depth++;
10949         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10950         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10951         ndr->depth++;
10952         if (r->driver_name) {
10953                 ndr_print_string(ndr, "driver_name", r->driver_name);
10954         }
10955         ndr->depth--;
10956         ndr_print_ptr(ndr, "architecture", r->architecture);
10957         ndr->depth++;
10958         if (r->architecture) {
10959                 ndr_print_string(ndr, "architecture", r->architecture);
10960         }
10961         ndr->depth--;
10962         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10963         ndr->depth++;
10964         if (r->driver_path) {
10965                 ndr_print_string(ndr, "driver_path", r->driver_path);
10966         }
10967         ndr->depth--;
10968         ndr_print_ptr(ndr, "data_file", r->data_file);
10969         ndr->depth++;
10970         if (r->data_file) {
10971                 ndr_print_string(ndr, "data_file", r->data_file);
10972         }
10973         ndr->depth--;
10974         ndr_print_ptr(ndr, "config_file", r->config_file);
10975         ndr->depth++;
10976         if (r->config_file) {
10977                 ndr_print_string(ndr, "config_file", r->config_file);
10978         }
10979         ndr->depth--;
10980         ndr_print_ptr(ndr, "help_file", r->help_file);
10981         ndr->depth++;
10982         if (r->help_file) {
10983                 ndr_print_string(ndr, "help_file", r->help_file);
10984         }
10985         ndr->depth--;
10986         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10987         ndr->depth++;
10988         if (r->dependent_files) {
10989                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
10990         }
10991         ndr->depth--;
10992         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10993         ndr->depth++;
10994         if (r->monitor_name) {
10995                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10996         }
10997         ndr->depth--;
10998         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10999         ndr->depth++;
11000         if (r->default_datatype) {
11001                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11002         }
11003         ndr->depth--;
11004         ndr->depth--;
11005 }
11006
11007 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
11008 {
11009         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
11010 }
11011
11012 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
11013 {
11014         if (ndr_flags & NDR_SCALARS) {
11015                 NDR_CHECK(ndr_push_align(ndr, 4));
11016                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11017                 {
11018                         uint32_t _flags_save_string = ndr->flags;
11019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11020                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11021                         ndr->flags = _flags_save_string;
11022                 }
11023                 {
11024                         uint32_t _flags_save_string = ndr->flags;
11025                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11026                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11027                         ndr->flags = _flags_save_string;
11028                 }
11029                 {
11030                         uint32_t _flags_save_string = ndr->flags;
11031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11032                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11033                         ndr->flags = _flags_save_string;
11034                 }
11035                 {
11036                         uint32_t _flags_save_string = ndr->flags;
11037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11038                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11039                         ndr->flags = _flags_save_string;
11040                 }
11041                 {
11042                         uint32_t _flags_save_string = ndr->flags;
11043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11044                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11045                         ndr->flags = _flags_save_string;
11046                 }
11047                 {
11048                         uint32_t _flags_save_string = ndr->flags;
11049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11050                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11051                         ndr->flags = _flags_save_string;
11052                 }
11053                 {
11054                         uint32_t _flags_save_string_array = ndr->flags;
11055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11056                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11057                         ndr->flags = _flags_save_string_array;
11058                 }
11059                 {
11060                         uint32_t _flags_save_string = ndr->flags;
11061                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11062                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11063                         ndr->flags = _flags_save_string;
11064                 }
11065                 {
11066                         uint32_t _flags_save_string = ndr->flags;
11067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11068                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11069                         ndr->flags = _flags_save_string;
11070                 }
11071                 {
11072                         uint32_t _flags_save_string_array = ndr->flags;
11073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11074                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11075                         ndr->flags = _flags_save_string_array;
11076                 }
11077         }
11078         if (ndr_flags & NDR_BUFFERS) {
11079                 {
11080                         uint32_t _flags_save_string = ndr->flags;
11081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11082                         if (r->driver_name) {
11083                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
11084                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11085                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
11086                         }
11087                         ndr->flags = _flags_save_string;
11088                 }
11089                 {
11090                         uint32_t _flags_save_string = ndr->flags;
11091                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11092                         if (r->architecture) {
11093                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
11094                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11095                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
11096                         }
11097                         ndr->flags = _flags_save_string;
11098                 }
11099                 {
11100                         uint32_t _flags_save_string = ndr->flags;
11101                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11102                         if (r->driver_path) {
11103                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
11104                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11105                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
11106                         }
11107                         ndr->flags = _flags_save_string;
11108                 }
11109                 {
11110                         uint32_t _flags_save_string = ndr->flags;
11111                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11112                         if (r->data_file) {
11113                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
11114                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11115                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
11116                         }
11117                         ndr->flags = _flags_save_string;
11118                 }
11119                 {
11120                         uint32_t _flags_save_string = ndr->flags;
11121                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11122                         if (r->config_file) {
11123                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
11124                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11125                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
11126                         }
11127                         ndr->flags = _flags_save_string;
11128                 }
11129                 {
11130                         uint32_t _flags_save_string = ndr->flags;
11131                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11132                         if (r->help_file) {
11133                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
11134                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11135                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
11136                         }
11137                         ndr->flags = _flags_save_string;
11138                 }
11139                 {
11140                         uint32_t _flags_save_string_array = ndr->flags;
11141                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11142                         if (r->dependent_files) {
11143                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
11144                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11145                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
11146                         }
11147                         ndr->flags = _flags_save_string_array;
11148                 }
11149                 {
11150                         uint32_t _flags_save_string = ndr->flags;
11151                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11152                         if (r->monitor_name) {
11153                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
11154                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11155                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
11156                         }
11157                         ndr->flags = _flags_save_string;
11158                 }
11159                 {
11160                         uint32_t _flags_save_string = ndr->flags;
11161                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11162                         if (r->default_datatype) {
11163                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
11164                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11165                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
11166                         }
11167                         ndr->flags = _flags_save_string;
11168                 }
11169                 {
11170                         uint32_t _flags_save_string_array = ndr->flags;
11171                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11172                         if (r->previous_names) {
11173                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
11174                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11175                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
11176                         }
11177                         ndr->flags = _flags_save_string_array;
11178                 }
11179         }
11180         return NDR_ERR_SUCCESS;
11181 }
11182
11183 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
11184 {
11185         uint32_t _ptr_driver_name;
11186         TALLOC_CTX *_mem_save_driver_name_0;
11187         uint32_t _ptr_architecture;
11188         TALLOC_CTX *_mem_save_architecture_0;
11189         uint32_t _ptr_driver_path;
11190         TALLOC_CTX *_mem_save_driver_path_0;
11191         uint32_t _ptr_data_file;
11192         TALLOC_CTX *_mem_save_data_file_0;
11193         uint32_t _ptr_config_file;
11194         TALLOC_CTX *_mem_save_config_file_0;
11195         uint32_t _ptr_help_file;
11196         TALLOC_CTX *_mem_save_help_file_0;
11197         uint32_t _ptr_dependent_files;
11198         TALLOC_CTX *_mem_save_dependent_files_0;
11199         uint32_t _ptr_monitor_name;
11200         TALLOC_CTX *_mem_save_monitor_name_0;
11201         uint32_t _ptr_default_datatype;
11202         TALLOC_CTX *_mem_save_default_datatype_0;
11203         uint32_t _ptr_previous_names;
11204         TALLOC_CTX *_mem_save_previous_names_0;
11205         if (ndr_flags & NDR_SCALARS) {
11206                 NDR_CHECK(ndr_pull_align(ndr, 4));
11207                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11208                 {
11209                         uint32_t _flags_save_string = ndr->flags;
11210                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11211                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11212                         if (_ptr_driver_name) {
11213                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11214                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11215                         } else {
11216                                 r->driver_name = NULL;
11217                         }
11218                         ndr->flags = _flags_save_string;
11219                 }
11220                 {
11221                         uint32_t _flags_save_string = ndr->flags;
11222                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11223                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11224                         if (_ptr_architecture) {
11225                                 NDR_PULL_ALLOC(ndr, r->architecture);
11226                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11227                         } else {
11228                                 r->architecture = NULL;
11229                         }
11230                         ndr->flags = _flags_save_string;
11231                 }
11232                 {
11233                         uint32_t _flags_save_string = ndr->flags;
11234                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11235                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11236                         if (_ptr_driver_path) {
11237                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11238                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11239                         } else {
11240                                 r->driver_path = NULL;
11241                         }
11242                         ndr->flags = _flags_save_string;
11243                 }
11244                 {
11245                         uint32_t _flags_save_string = ndr->flags;
11246                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11247                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11248                         if (_ptr_data_file) {
11249                                 NDR_PULL_ALLOC(ndr, r->data_file);
11250                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11251                         } else {
11252                                 r->data_file = NULL;
11253                         }
11254                         ndr->flags = _flags_save_string;
11255                 }
11256                 {
11257                         uint32_t _flags_save_string = ndr->flags;
11258                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11259                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11260                         if (_ptr_config_file) {
11261                                 NDR_PULL_ALLOC(ndr, r->config_file);
11262                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11263                         } else {
11264                                 r->config_file = NULL;
11265                         }
11266                         ndr->flags = _flags_save_string;
11267                 }
11268                 {
11269                         uint32_t _flags_save_string = ndr->flags;
11270                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11271                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11272                         if (_ptr_help_file) {
11273                                 NDR_PULL_ALLOC(ndr, r->help_file);
11274                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11275                         } else {
11276                                 r->help_file = NULL;
11277                         }
11278                         ndr->flags = _flags_save_string;
11279                 }
11280                 {
11281                         uint32_t _flags_save_string_array = ndr->flags;
11282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11283                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11284                         if (_ptr_dependent_files) {
11285                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11286                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11287                         } else {
11288                                 r->dependent_files = NULL;
11289                         }
11290                         ndr->flags = _flags_save_string_array;
11291                 }
11292                 {
11293                         uint32_t _flags_save_string = ndr->flags;
11294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11295                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11296                         if (_ptr_monitor_name) {
11297                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11298                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11299                         } else {
11300                                 r->monitor_name = NULL;
11301                         }
11302                         ndr->flags = _flags_save_string;
11303                 }
11304                 {
11305                         uint32_t _flags_save_string = ndr->flags;
11306                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11307                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11308                         if (_ptr_default_datatype) {
11309                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11310                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11311                         } else {
11312                                 r->default_datatype = NULL;
11313                         }
11314                         ndr->flags = _flags_save_string;
11315                 }
11316                 {
11317                         uint32_t _flags_save_string_array = ndr->flags;
11318                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11319                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11320                         if (_ptr_previous_names) {
11321                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11322                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11323                         } else {
11324                                 r->previous_names = NULL;
11325                         }
11326                         ndr->flags = _flags_save_string_array;
11327                 }
11328         }
11329         if (ndr_flags & NDR_BUFFERS) {
11330                 {
11331                         uint32_t _flags_save_string = ndr->flags;
11332                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11333                         if (r->driver_name) {
11334                                 uint32_t _relative_save_offset;
11335                                 _relative_save_offset = ndr->offset;
11336                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11337                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11338                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11339                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11340                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11341                                 ndr->offset = _relative_save_offset;
11342                         }
11343                         ndr->flags = _flags_save_string;
11344                 }
11345                 {
11346                         uint32_t _flags_save_string = ndr->flags;
11347                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11348                         if (r->architecture) {
11349                                 uint32_t _relative_save_offset;
11350                                 _relative_save_offset = ndr->offset;
11351                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11352                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11353                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11354                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11355                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11356                                 ndr->offset = _relative_save_offset;
11357                         }
11358                         ndr->flags = _flags_save_string;
11359                 }
11360                 {
11361                         uint32_t _flags_save_string = ndr->flags;
11362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11363                         if (r->driver_path) {
11364                                 uint32_t _relative_save_offset;
11365                                 _relative_save_offset = ndr->offset;
11366                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11367                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11368                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11369                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11370                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11371                                 ndr->offset = _relative_save_offset;
11372                         }
11373                         ndr->flags = _flags_save_string;
11374                 }
11375                 {
11376                         uint32_t _flags_save_string = ndr->flags;
11377                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11378                         if (r->data_file) {
11379                                 uint32_t _relative_save_offset;
11380                                 _relative_save_offset = ndr->offset;
11381                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11382                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11383                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11384                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11385                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11386                                 ndr->offset = _relative_save_offset;
11387                         }
11388                         ndr->flags = _flags_save_string;
11389                 }
11390                 {
11391                         uint32_t _flags_save_string = ndr->flags;
11392                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11393                         if (r->config_file) {
11394                                 uint32_t _relative_save_offset;
11395                                 _relative_save_offset = ndr->offset;
11396                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11397                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11398                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11399                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11400                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11401                                 ndr->offset = _relative_save_offset;
11402                         }
11403                         ndr->flags = _flags_save_string;
11404                 }
11405                 {
11406                         uint32_t _flags_save_string = ndr->flags;
11407                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11408                         if (r->help_file) {
11409                                 uint32_t _relative_save_offset;
11410                                 _relative_save_offset = ndr->offset;
11411                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11412                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11413                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11414                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11415                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11416                                 ndr->offset = _relative_save_offset;
11417                         }
11418                         ndr->flags = _flags_save_string;
11419                 }
11420                 {
11421                         uint32_t _flags_save_string_array = ndr->flags;
11422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11423                         if (r->dependent_files) {
11424                                 uint32_t _relative_save_offset;
11425                                 _relative_save_offset = ndr->offset;
11426                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11427                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11428                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11429                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11430                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11431                                 ndr->offset = _relative_save_offset;
11432                         }
11433                         ndr->flags = _flags_save_string_array;
11434                 }
11435                 {
11436                         uint32_t _flags_save_string = ndr->flags;
11437                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11438                         if (r->monitor_name) {
11439                                 uint32_t _relative_save_offset;
11440                                 _relative_save_offset = ndr->offset;
11441                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11442                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11443                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11444                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11445                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11446                                 ndr->offset = _relative_save_offset;
11447                         }
11448                         ndr->flags = _flags_save_string;
11449                 }
11450                 {
11451                         uint32_t _flags_save_string = ndr->flags;
11452                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11453                         if (r->default_datatype) {
11454                                 uint32_t _relative_save_offset;
11455                                 _relative_save_offset = ndr->offset;
11456                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11457                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11458                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11459                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11460                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11461                                 ndr->offset = _relative_save_offset;
11462                         }
11463                         ndr->flags = _flags_save_string;
11464                 }
11465                 {
11466                         uint32_t _flags_save_string_array = ndr->flags;
11467                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11468                         if (r->previous_names) {
11469                                 uint32_t _relative_save_offset;
11470                                 _relative_save_offset = ndr->offset;
11471                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11472                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11473                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11474                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11475                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11476                                 ndr->offset = _relative_save_offset;
11477                         }
11478                         ndr->flags = _flags_save_string_array;
11479                 }
11480         }
11481         return NDR_ERR_SUCCESS;
11482 }
11483
11484 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11485 {
11486         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11487         ndr->depth++;
11488         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11489         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11490         ndr->depth++;
11491         if (r->driver_name) {
11492                 ndr_print_string(ndr, "driver_name", r->driver_name);
11493         }
11494         ndr->depth--;
11495         ndr_print_ptr(ndr, "architecture", r->architecture);
11496         ndr->depth++;
11497         if (r->architecture) {
11498                 ndr_print_string(ndr, "architecture", r->architecture);
11499         }
11500         ndr->depth--;
11501         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11502         ndr->depth++;
11503         if (r->driver_path) {
11504                 ndr_print_string(ndr, "driver_path", r->driver_path);
11505         }
11506         ndr->depth--;
11507         ndr_print_ptr(ndr, "data_file", r->data_file);
11508         ndr->depth++;
11509         if (r->data_file) {
11510                 ndr_print_string(ndr, "data_file", r->data_file);
11511         }
11512         ndr->depth--;
11513         ndr_print_ptr(ndr, "config_file", r->config_file);
11514         ndr->depth++;
11515         if (r->config_file) {
11516                 ndr_print_string(ndr, "config_file", r->config_file);
11517         }
11518         ndr->depth--;
11519         ndr_print_ptr(ndr, "help_file", r->help_file);
11520         ndr->depth++;
11521         if (r->help_file) {
11522                 ndr_print_string(ndr, "help_file", r->help_file);
11523         }
11524         ndr->depth--;
11525         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11526         ndr->depth++;
11527         if (r->dependent_files) {
11528                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11529         }
11530         ndr->depth--;
11531         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11532         ndr->depth++;
11533         if (r->monitor_name) {
11534                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11535         }
11536         ndr->depth--;
11537         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11538         ndr->depth++;
11539         if (r->default_datatype) {
11540                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11541         }
11542         ndr->depth--;
11543         ndr_print_ptr(ndr, "previous_names", r->previous_names);
11544         ndr->depth++;
11545         if (r->previous_names) {
11546                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
11547         }
11548         ndr->depth--;
11549         ndr->depth--;
11550 }
11551
11552 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
11553 {
11554         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
11555 }
11556
11557 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
11558 {
11559         if (ndr_flags & NDR_SCALARS) {
11560                 NDR_CHECK(ndr_push_align(ndr, 4));
11561                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11562                 {
11563                         uint32_t _flags_save_string = ndr->flags;
11564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11565                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11566                         ndr->flags = _flags_save_string;
11567                 }
11568                 {
11569                         uint32_t _flags_save_string = ndr->flags;
11570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11571                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11572                         ndr->flags = _flags_save_string;
11573                 }
11574                 {
11575                         uint32_t _flags_save_string = ndr->flags;
11576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11577                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11578                         ndr->flags = _flags_save_string;
11579                 }
11580                 {
11581                         uint32_t _flags_save_string = ndr->flags;
11582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11583                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11584                         ndr->flags = _flags_save_string;
11585                 }
11586                 {
11587                         uint32_t _flags_save_string = ndr->flags;
11588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11589                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11590                         ndr->flags = _flags_save_string;
11591                 }
11592                 NDR_CHECK(ndr_push_spoolss_DriverAttributes(ndr, NDR_SCALARS, r->driver_attributes));
11593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
11594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
11595         }
11596         if (ndr_flags & NDR_BUFFERS) {
11597                 {
11598                         uint32_t _flags_save_string = ndr->flags;
11599                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11600                         if (r->driver_name) {
11601                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
11602                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11603                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
11604                         }
11605                         ndr->flags = _flags_save_string;
11606                 }
11607                 {
11608                         uint32_t _flags_save_string = ndr->flags;
11609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11610                         if (r->architecture) {
11611                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
11612                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11613                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
11614                         }
11615                         ndr->flags = _flags_save_string;
11616                 }
11617                 {
11618                         uint32_t _flags_save_string = ndr->flags;
11619                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11620                         if (r->driver_path) {
11621                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
11622                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11623                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
11624                         }
11625                         ndr->flags = _flags_save_string;
11626                 }
11627                 {
11628                         uint32_t _flags_save_string = ndr->flags;
11629                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11630                         if (r->data_file) {
11631                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
11632                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11633                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
11634                         }
11635                         ndr->flags = _flags_save_string;
11636                 }
11637                 {
11638                         uint32_t _flags_save_string = ndr->flags;
11639                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11640                         if (r->config_file) {
11641                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
11642                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11643                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
11644                         }
11645                         ndr->flags = _flags_save_string;
11646                 }
11647         }
11648         return NDR_ERR_SUCCESS;
11649 }
11650
11651 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
11652 {
11653         uint32_t _ptr_driver_name;
11654         TALLOC_CTX *_mem_save_driver_name_0;
11655         uint32_t _ptr_architecture;
11656         TALLOC_CTX *_mem_save_architecture_0;
11657         uint32_t _ptr_driver_path;
11658         TALLOC_CTX *_mem_save_driver_path_0;
11659         uint32_t _ptr_data_file;
11660         TALLOC_CTX *_mem_save_data_file_0;
11661         uint32_t _ptr_config_file;
11662         TALLOC_CTX *_mem_save_config_file_0;
11663         if (ndr_flags & NDR_SCALARS) {
11664                 NDR_CHECK(ndr_pull_align(ndr, 4));
11665                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11666                 {
11667                         uint32_t _flags_save_string = ndr->flags;
11668                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11669                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11670                         if (_ptr_driver_name) {
11671                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11672                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11673                         } else {
11674                                 r->driver_name = NULL;
11675                         }
11676                         ndr->flags = _flags_save_string;
11677                 }
11678                 {
11679                         uint32_t _flags_save_string = ndr->flags;
11680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11681                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11682                         if (_ptr_architecture) {
11683                                 NDR_PULL_ALLOC(ndr, r->architecture);
11684                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11685                         } else {
11686                                 r->architecture = NULL;
11687                         }
11688                         ndr->flags = _flags_save_string;
11689                 }
11690                 {
11691                         uint32_t _flags_save_string = ndr->flags;
11692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11693                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11694                         if (_ptr_driver_path) {
11695                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11696                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11697                         } else {
11698                                 r->driver_path = NULL;
11699                         }
11700                         ndr->flags = _flags_save_string;
11701                 }
11702                 {
11703                         uint32_t _flags_save_string = ndr->flags;
11704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11705                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11706                         if (_ptr_data_file) {
11707                                 NDR_PULL_ALLOC(ndr, r->data_file);
11708                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11709                         } else {
11710                                 r->data_file = NULL;
11711                         }
11712                         ndr->flags = _flags_save_string;
11713                 }
11714                 {
11715                         uint32_t _flags_save_string = ndr->flags;
11716                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11717                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11718                         if (_ptr_config_file) {
11719                                 NDR_PULL_ALLOC(ndr, r->config_file);
11720                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11721                         } else {
11722                                 r->config_file = NULL;
11723                         }
11724                         ndr->flags = _flags_save_string;
11725                 }
11726                 NDR_CHECK(ndr_pull_spoolss_DriverAttributes(ndr, NDR_SCALARS, &r->driver_attributes));
11727                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
11728                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
11729         }
11730         if (ndr_flags & NDR_BUFFERS) {
11731                 {
11732                         uint32_t _flags_save_string = ndr->flags;
11733                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11734                         if (r->driver_name) {
11735                                 uint32_t _relative_save_offset;
11736                                 _relative_save_offset = ndr->offset;
11737                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11738                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11739                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11740                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11741                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11742                                 ndr->offset = _relative_save_offset;
11743                         }
11744                         ndr->flags = _flags_save_string;
11745                 }
11746                 {
11747                         uint32_t _flags_save_string = ndr->flags;
11748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11749                         if (r->architecture) {
11750                                 uint32_t _relative_save_offset;
11751                                 _relative_save_offset = ndr->offset;
11752                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11753                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11754                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11755                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11756                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11757                                 ndr->offset = _relative_save_offset;
11758                         }
11759                         ndr->flags = _flags_save_string;
11760                 }
11761                 {
11762                         uint32_t _flags_save_string = ndr->flags;
11763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11764                         if (r->driver_path) {
11765                                 uint32_t _relative_save_offset;
11766                                 _relative_save_offset = ndr->offset;
11767                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11768                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11769                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11770                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11771                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11772                                 ndr->offset = _relative_save_offset;
11773                         }
11774                         ndr->flags = _flags_save_string;
11775                 }
11776                 {
11777                         uint32_t _flags_save_string = ndr->flags;
11778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11779                         if (r->data_file) {
11780                                 uint32_t _relative_save_offset;
11781                                 _relative_save_offset = ndr->offset;
11782                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11783                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11784                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11785                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11786                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11787                                 ndr->offset = _relative_save_offset;
11788                         }
11789                         ndr->flags = _flags_save_string;
11790                 }
11791                 {
11792                         uint32_t _flags_save_string = ndr->flags;
11793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11794                         if (r->config_file) {
11795                                 uint32_t _relative_save_offset;
11796                                 _relative_save_offset = ndr->offset;
11797                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11798                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11799                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11800                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11801                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11802                                 ndr->offset = _relative_save_offset;
11803                         }
11804                         ndr->flags = _flags_save_string;
11805                 }
11806         }
11807         return NDR_ERR_SUCCESS;
11808 }
11809
11810 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
11811 {
11812         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
11813         ndr->depth++;
11814         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11815         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11816         ndr->depth++;
11817         if (r->driver_name) {
11818                 ndr_print_string(ndr, "driver_name", r->driver_name);
11819         }
11820         ndr->depth--;
11821         ndr_print_ptr(ndr, "architecture", r->architecture);
11822         ndr->depth++;
11823         if (r->architecture) {
11824                 ndr_print_string(ndr, "architecture", r->architecture);
11825         }
11826         ndr->depth--;
11827         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11828         ndr->depth++;
11829         if (r->driver_path) {
11830                 ndr_print_string(ndr, "driver_path", r->driver_path);
11831         }
11832         ndr->depth--;
11833         ndr_print_ptr(ndr, "data_file", r->data_file);
11834         ndr->depth++;
11835         if (r->data_file) {
11836                 ndr_print_string(ndr, "data_file", r->data_file);
11837         }
11838         ndr->depth--;
11839         ndr_print_ptr(ndr, "config_file", r->config_file);
11840         ndr->depth++;
11841         if (r->config_file) {
11842                 ndr_print_string(ndr, "config_file", r->config_file);
11843         }
11844         ndr->depth--;
11845         ndr_print_spoolss_DriverAttributes(ndr, "driver_attributes", r->driver_attributes);
11846         ndr_print_uint32(ndr, "config_version", r->config_version);
11847         ndr_print_uint32(ndr, "driver_version", r->driver_version);
11848         ndr->depth--;
11849 }
11850
11851 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
11852 {
11853         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
11854 }
11855
11856 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
11857 {
11858         if (ndr_flags & NDR_SCALARS) {
11859                 NDR_CHECK(ndr_push_align(ndr, 8));
11860                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11861                 {
11862                         uint32_t _flags_save_string = ndr->flags;
11863                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11864                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11865                         ndr->flags = _flags_save_string;
11866                 }
11867                 {
11868                         uint32_t _flags_save_string = ndr->flags;
11869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11870                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11871                         ndr->flags = _flags_save_string;
11872                 }
11873                 {
11874                         uint32_t _flags_save_string = ndr->flags;
11875                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11876                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11877                         ndr->flags = _flags_save_string;
11878                 }
11879                 {
11880                         uint32_t _flags_save_string = ndr->flags;
11881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11882                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11883                         ndr->flags = _flags_save_string;
11884                 }
11885                 {
11886                         uint32_t _flags_save_string = ndr->flags;
11887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11888                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11889                         ndr->flags = _flags_save_string;
11890                 }
11891                 {
11892                         uint32_t _flags_save_string = ndr->flags;
11893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11894                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11895                         ndr->flags = _flags_save_string;
11896                 }
11897                 {
11898                         uint32_t _flags_save_string_array = ndr->flags;
11899                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11900                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11901                         ndr->flags = _flags_save_string_array;
11902                 }
11903                 {
11904                         uint32_t _flags_save_string = ndr->flags;
11905                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11906                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11907                         ndr->flags = _flags_save_string;
11908                 }
11909                 {
11910                         uint32_t _flags_save_string = ndr->flags;
11911                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11912                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11913                         ndr->flags = _flags_save_string;
11914                 }
11915                 {
11916                         uint32_t _flags_save_string_array = ndr->flags;
11917                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11918                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11919                         ndr->flags = _flags_save_string_array;
11920                 }
11921                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
11922                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
11923                 {
11924                         uint32_t _flags_save_string = ndr->flags;
11925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11926                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
11927                         ndr->flags = _flags_save_string;
11928                 }
11929                 {
11930                         uint32_t _flags_save_string = ndr->flags;
11931                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11932                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
11933                         ndr->flags = _flags_save_string;
11934                 }
11935                 {
11936                         uint32_t _flags_save_string = ndr->flags;
11937                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11938                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
11939                         ndr->flags = _flags_save_string;
11940                 }
11941                 {
11942                         uint32_t _flags_save_string = ndr->flags;
11943                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11944                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
11945                         ndr->flags = _flags_save_string;
11946                 }
11947         }
11948         if (ndr_flags & NDR_BUFFERS) {
11949                 {
11950                         uint32_t _flags_save_string = ndr->flags;
11951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11952                         if (r->driver_name) {
11953                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
11954                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11955                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
11956                         }
11957                         ndr->flags = _flags_save_string;
11958                 }
11959                 {
11960                         uint32_t _flags_save_string = ndr->flags;
11961                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11962                         if (r->architecture) {
11963                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
11964                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11965                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
11966                         }
11967                         ndr->flags = _flags_save_string;
11968                 }
11969                 {
11970                         uint32_t _flags_save_string = ndr->flags;
11971                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11972                         if (r->driver_path) {
11973                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
11974                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11975                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
11976                         }
11977                         ndr->flags = _flags_save_string;
11978                 }
11979                 {
11980                         uint32_t _flags_save_string = ndr->flags;
11981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11982                         if (r->data_file) {
11983                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
11984                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11985                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
11986                         }
11987                         ndr->flags = _flags_save_string;
11988                 }
11989                 {
11990                         uint32_t _flags_save_string = ndr->flags;
11991                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11992                         if (r->config_file) {
11993                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
11994                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11995                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
11996                         }
11997                         ndr->flags = _flags_save_string;
11998                 }
11999                 {
12000                         uint32_t _flags_save_string = ndr->flags;
12001                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12002                         if (r->help_file) {
12003                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
12004                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12005                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
12006                         }
12007                         ndr->flags = _flags_save_string;
12008                 }
12009                 {
12010                         uint32_t _flags_save_string_array = ndr->flags;
12011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12012                         if (r->dependent_files) {
12013                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
12014                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12015                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
12016                         }
12017                         ndr->flags = _flags_save_string_array;
12018                 }
12019                 {
12020                         uint32_t _flags_save_string = ndr->flags;
12021                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12022                         if (r->monitor_name) {
12023                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
12024                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12025                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
12026                         }
12027                         ndr->flags = _flags_save_string;
12028                 }
12029                 {
12030                         uint32_t _flags_save_string = ndr->flags;
12031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12032                         if (r->default_datatype) {
12033                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
12034                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12035                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
12036                         }
12037                         ndr->flags = _flags_save_string;
12038                 }
12039                 {
12040                         uint32_t _flags_save_string_array = ndr->flags;
12041                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12042                         if (r->previous_names) {
12043                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
12044                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12045                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
12046                         }
12047                         ndr->flags = _flags_save_string_array;
12048                 }
12049                 {
12050                         uint32_t _flags_save_string = ndr->flags;
12051                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12052                         if (r->manufacturer_name) {
12053                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_name));
12054                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12055                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_name));
12056                         }
12057                         ndr->flags = _flags_save_string;
12058                 }
12059                 {
12060                         uint32_t _flags_save_string = ndr->flags;
12061                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12062                         if (r->manufacturer_url) {
12063                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_url));
12064                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12065                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_url));
12066                         }
12067                         ndr->flags = _flags_save_string;
12068                 }
12069                 {
12070                         uint32_t _flags_save_string = ndr->flags;
12071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12072                         if (r->hardware_id) {
12073                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->hardware_id));
12074                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12075                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->hardware_id));
12076                         }
12077                         ndr->flags = _flags_save_string;
12078                 }
12079                 {
12080                         uint32_t _flags_save_string = ndr->flags;
12081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12082                         if (r->provider) {
12083                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->provider));
12084                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12085                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->provider));
12086                         }
12087                         ndr->flags = _flags_save_string;
12088                 }
12089         }
12090         return NDR_ERR_SUCCESS;
12091 }
12092
12093 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
12094 {
12095         uint32_t _ptr_driver_name;
12096         TALLOC_CTX *_mem_save_driver_name_0;
12097         uint32_t _ptr_architecture;
12098         TALLOC_CTX *_mem_save_architecture_0;
12099         uint32_t _ptr_driver_path;
12100         TALLOC_CTX *_mem_save_driver_path_0;
12101         uint32_t _ptr_data_file;
12102         TALLOC_CTX *_mem_save_data_file_0;
12103         uint32_t _ptr_config_file;
12104         TALLOC_CTX *_mem_save_config_file_0;
12105         uint32_t _ptr_help_file;
12106         TALLOC_CTX *_mem_save_help_file_0;
12107         uint32_t _ptr_dependent_files;
12108         TALLOC_CTX *_mem_save_dependent_files_0;
12109         uint32_t _ptr_monitor_name;
12110         TALLOC_CTX *_mem_save_monitor_name_0;
12111         uint32_t _ptr_default_datatype;
12112         TALLOC_CTX *_mem_save_default_datatype_0;
12113         uint32_t _ptr_previous_names;
12114         TALLOC_CTX *_mem_save_previous_names_0;
12115         uint32_t _ptr_manufacturer_name;
12116         TALLOC_CTX *_mem_save_manufacturer_name_0;
12117         uint32_t _ptr_manufacturer_url;
12118         TALLOC_CTX *_mem_save_manufacturer_url_0;
12119         uint32_t _ptr_hardware_id;
12120         TALLOC_CTX *_mem_save_hardware_id_0;
12121         uint32_t _ptr_provider;
12122         TALLOC_CTX *_mem_save_provider_0;
12123         if (ndr_flags & NDR_SCALARS) {
12124                 NDR_CHECK(ndr_pull_align(ndr, 8));
12125                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12126                 {
12127                         uint32_t _flags_save_string = ndr->flags;
12128                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12129                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12130                         if (_ptr_driver_name) {
12131                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12132                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12133                         } else {
12134                                 r->driver_name = NULL;
12135                         }
12136                         ndr->flags = _flags_save_string;
12137                 }
12138                 {
12139                         uint32_t _flags_save_string = ndr->flags;
12140                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12141                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12142                         if (_ptr_architecture) {
12143                                 NDR_PULL_ALLOC(ndr, r->architecture);
12144                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12145                         } else {
12146                                 r->architecture = NULL;
12147                         }
12148                         ndr->flags = _flags_save_string;
12149                 }
12150                 {
12151                         uint32_t _flags_save_string = ndr->flags;
12152                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12153                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12154                         if (_ptr_driver_path) {
12155                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12156                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12157                         } else {
12158                                 r->driver_path = NULL;
12159                         }
12160                         ndr->flags = _flags_save_string;
12161                 }
12162                 {
12163                         uint32_t _flags_save_string = ndr->flags;
12164                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12165                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12166                         if (_ptr_data_file) {
12167                                 NDR_PULL_ALLOC(ndr, r->data_file);
12168                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12169                         } else {
12170                                 r->data_file = NULL;
12171                         }
12172                         ndr->flags = _flags_save_string;
12173                 }
12174                 {
12175                         uint32_t _flags_save_string = ndr->flags;
12176                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12177                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12178                         if (_ptr_config_file) {
12179                                 NDR_PULL_ALLOC(ndr, r->config_file);
12180                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12181                         } else {
12182                                 r->config_file = NULL;
12183                         }
12184                         ndr->flags = _flags_save_string;
12185                 }
12186                 {
12187                         uint32_t _flags_save_string = ndr->flags;
12188                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12189                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12190                         if (_ptr_help_file) {
12191                                 NDR_PULL_ALLOC(ndr, r->help_file);
12192                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12193                         } else {
12194                                 r->help_file = NULL;
12195                         }
12196                         ndr->flags = _flags_save_string;
12197                 }
12198                 {
12199                         uint32_t _flags_save_string_array = ndr->flags;
12200                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12201                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12202                         if (_ptr_dependent_files) {
12203                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12204                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12205                         } else {
12206                                 r->dependent_files = NULL;
12207                         }
12208                         ndr->flags = _flags_save_string_array;
12209                 }
12210                 {
12211                         uint32_t _flags_save_string = ndr->flags;
12212                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12213                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12214                         if (_ptr_monitor_name) {
12215                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12216                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12217                         } else {
12218                                 r->monitor_name = NULL;
12219                         }
12220                         ndr->flags = _flags_save_string;
12221                 }
12222                 {
12223                         uint32_t _flags_save_string = ndr->flags;
12224                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12225                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12226                         if (_ptr_default_datatype) {
12227                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12228                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12229                         } else {
12230                                 r->default_datatype = NULL;
12231                         }
12232                         ndr->flags = _flags_save_string;
12233                 }
12234                 {
12235                         uint32_t _flags_save_string_array = ndr->flags;
12236                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12237                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12238                         if (_ptr_previous_names) {
12239                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12240                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12241                         } else {
12242                                 r->previous_names = NULL;
12243                         }
12244                         ndr->flags = _flags_save_string_array;
12245                 }
12246                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12247                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12248                 {
12249                         uint32_t _flags_save_string = ndr->flags;
12250                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12251                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12252                         if (_ptr_manufacturer_name) {
12253                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12254                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12255                         } else {
12256                                 r->manufacturer_name = NULL;
12257                         }
12258                         ndr->flags = _flags_save_string;
12259                 }
12260                 {
12261                         uint32_t _flags_save_string = ndr->flags;
12262                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12263                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12264                         if (_ptr_manufacturer_url) {
12265                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12266                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12267                         } else {
12268                                 r->manufacturer_url = NULL;
12269                         }
12270                         ndr->flags = _flags_save_string;
12271                 }
12272                 {
12273                         uint32_t _flags_save_string = ndr->flags;
12274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12275                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12276                         if (_ptr_hardware_id) {
12277                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12278                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12279                         } else {
12280                                 r->hardware_id = NULL;
12281                         }
12282                         ndr->flags = _flags_save_string;
12283                 }
12284                 {
12285                         uint32_t _flags_save_string = ndr->flags;
12286                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12287                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12288                         if (_ptr_provider) {
12289                                 NDR_PULL_ALLOC(ndr, r->provider);
12290                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12291                         } else {
12292                                 r->provider = NULL;
12293                         }
12294                         ndr->flags = _flags_save_string;
12295                 }
12296         }
12297         if (ndr_flags & NDR_BUFFERS) {
12298                 {
12299                         uint32_t _flags_save_string = ndr->flags;
12300                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12301                         if (r->driver_name) {
12302                                 uint32_t _relative_save_offset;
12303                                 _relative_save_offset = ndr->offset;
12304                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12305                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12306                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12307                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12308                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12309                                 ndr->offset = _relative_save_offset;
12310                         }
12311                         ndr->flags = _flags_save_string;
12312                 }
12313                 {
12314                         uint32_t _flags_save_string = ndr->flags;
12315                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12316                         if (r->architecture) {
12317                                 uint32_t _relative_save_offset;
12318                                 _relative_save_offset = ndr->offset;
12319                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12320                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12321                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12322                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12323                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12324                                 ndr->offset = _relative_save_offset;
12325                         }
12326                         ndr->flags = _flags_save_string;
12327                 }
12328                 {
12329                         uint32_t _flags_save_string = ndr->flags;
12330                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12331                         if (r->driver_path) {
12332                                 uint32_t _relative_save_offset;
12333                                 _relative_save_offset = ndr->offset;
12334                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12335                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12336                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12337                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12338                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12339                                 ndr->offset = _relative_save_offset;
12340                         }
12341                         ndr->flags = _flags_save_string;
12342                 }
12343                 {
12344                         uint32_t _flags_save_string = ndr->flags;
12345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12346                         if (r->data_file) {
12347                                 uint32_t _relative_save_offset;
12348                                 _relative_save_offset = ndr->offset;
12349                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12350                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12351                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12352                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12353                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12354                                 ndr->offset = _relative_save_offset;
12355                         }
12356                         ndr->flags = _flags_save_string;
12357                 }
12358                 {
12359                         uint32_t _flags_save_string = ndr->flags;
12360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12361                         if (r->config_file) {
12362                                 uint32_t _relative_save_offset;
12363                                 _relative_save_offset = ndr->offset;
12364                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12365                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12366                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12367                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12368                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12369                                 ndr->offset = _relative_save_offset;
12370                         }
12371                         ndr->flags = _flags_save_string;
12372                 }
12373                 {
12374                         uint32_t _flags_save_string = ndr->flags;
12375                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12376                         if (r->help_file) {
12377                                 uint32_t _relative_save_offset;
12378                                 _relative_save_offset = ndr->offset;
12379                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12380                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12381                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12382                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12383                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12384                                 ndr->offset = _relative_save_offset;
12385                         }
12386                         ndr->flags = _flags_save_string;
12387                 }
12388                 {
12389                         uint32_t _flags_save_string_array = ndr->flags;
12390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12391                         if (r->dependent_files) {
12392                                 uint32_t _relative_save_offset;
12393                                 _relative_save_offset = ndr->offset;
12394                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12395                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12396                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12397                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12398                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12399                                 ndr->offset = _relative_save_offset;
12400                         }
12401                         ndr->flags = _flags_save_string_array;
12402                 }
12403                 {
12404                         uint32_t _flags_save_string = ndr->flags;
12405                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12406                         if (r->monitor_name) {
12407                                 uint32_t _relative_save_offset;
12408                                 _relative_save_offset = ndr->offset;
12409                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12410                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12411                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12412                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12413                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12414                                 ndr->offset = _relative_save_offset;
12415                         }
12416                         ndr->flags = _flags_save_string;
12417                 }
12418                 {
12419                         uint32_t _flags_save_string = ndr->flags;
12420                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12421                         if (r->default_datatype) {
12422                                 uint32_t _relative_save_offset;
12423                                 _relative_save_offset = ndr->offset;
12424                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12425                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12426                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12427                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12428                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12429                                 ndr->offset = _relative_save_offset;
12430                         }
12431                         ndr->flags = _flags_save_string;
12432                 }
12433                 {
12434                         uint32_t _flags_save_string_array = ndr->flags;
12435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12436                         if (r->previous_names) {
12437                                 uint32_t _relative_save_offset;
12438                                 _relative_save_offset = ndr->offset;
12439                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12440                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12441                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12442                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12443                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12444                                 ndr->offset = _relative_save_offset;
12445                         }
12446                         ndr->flags = _flags_save_string_array;
12447                 }
12448                 {
12449                         uint32_t _flags_save_string = ndr->flags;
12450                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12451                         if (r->manufacturer_name) {
12452                                 uint32_t _relative_save_offset;
12453                                 _relative_save_offset = ndr->offset;
12454                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12455                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12456                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12457                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12458                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12459                                 ndr->offset = _relative_save_offset;
12460                         }
12461                         ndr->flags = _flags_save_string;
12462                 }
12463                 {
12464                         uint32_t _flags_save_string = ndr->flags;
12465                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12466                         if (r->manufacturer_url) {
12467                                 uint32_t _relative_save_offset;
12468                                 _relative_save_offset = ndr->offset;
12469                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12470                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12471                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12472                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12473                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12474                                 ndr->offset = _relative_save_offset;
12475                         }
12476                         ndr->flags = _flags_save_string;
12477                 }
12478                 {
12479                         uint32_t _flags_save_string = ndr->flags;
12480                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12481                         if (r->hardware_id) {
12482                                 uint32_t _relative_save_offset;
12483                                 _relative_save_offset = ndr->offset;
12484                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12485                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12486                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12487                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12488                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12489                                 ndr->offset = _relative_save_offset;
12490                         }
12491                         ndr->flags = _flags_save_string;
12492                 }
12493                 {
12494                         uint32_t _flags_save_string = ndr->flags;
12495                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12496                         if (r->provider) {
12497                                 uint32_t _relative_save_offset;
12498                                 _relative_save_offset = ndr->offset;
12499                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12500                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12501                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12502                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12503                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12504                                 ndr->offset = _relative_save_offset;
12505                         }
12506                         ndr->flags = _flags_save_string;
12507                 }
12508         }
12509         return NDR_ERR_SUCCESS;
12510 }
12511
12512 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
12513 {
12514         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
12515         ndr->depth++;
12516         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12517         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12518         ndr->depth++;
12519         if (r->driver_name) {
12520                 ndr_print_string(ndr, "driver_name", r->driver_name);
12521         }
12522         ndr->depth--;
12523         ndr_print_ptr(ndr, "architecture", r->architecture);
12524         ndr->depth++;
12525         if (r->architecture) {
12526                 ndr_print_string(ndr, "architecture", r->architecture);
12527         }
12528         ndr->depth--;
12529         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12530         ndr->depth++;
12531         if (r->driver_path) {
12532                 ndr_print_string(ndr, "driver_path", r->driver_path);
12533         }
12534         ndr->depth--;
12535         ndr_print_ptr(ndr, "data_file", r->data_file);
12536         ndr->depth++;
12537         if (r->data_file) {
12538                 ndr_print_string(ndr, "data_file", r->data_file);
12539         }
12540         ndr->depth--;
12541         ndr_print_ptr(ndr, "config_file", r->config_file);
12542         ndr->depth++;
12543         if (r->config_file) {
12544                 ndr_print_string(ndr, "config_file", r->config_file);
12545         }
12546         ndr->depth--;
12547         ndr_print_ptr(ndr, "help_file", r->help_file);
12548         ndr->depth++;
12549         if (r->help_file) {
12550                 ndr_print_string(ndr, "help_file", r->help_file);
12551         }
12552         ndr->depth--;
12553         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12554         ndr->depth++;
12555         if (r->dependent_files) {
12556                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12557         }
12558         ndr->depth--;
12559         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12560         ndr->depth++;
12561         if (r->monitor_name) {
12562                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12563         }
12564         ndr->depth--;
12565         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12566         ndr->depth++;
12567         if (r->default_datatype) {
12568                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12569         }
12570         ndr->depth--;
12571         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12572         ndr->depth++;
12573         if (r->previous_names) {
12574                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12575         }
12576         ndr->depth--;
12577         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
12578         ndr_print_hyper(ndr, "driver_version", r->driver_version);
12579         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
12580         ndr->depth++;
12581         if (r->manufacturer_name) {
12582                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
12583         }
12584         ndr->depth--;
12585         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
12586         ndr->depth++;
12587         if (r->manufacturer_url) {
12588                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
12589         }
12590         ndr->depth--;
12591         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
12592         ndr->depth++;
12593         if (r->hardware_id) {
12594                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
12595         }
12596         ndr->depth--;
12597         ndr_print_ptr(ndr, "provider", r->provider);
12598         ndr->depth++;
12599         if (r->provider) {
12600                 ndr_print_string(ndr, "provider", r->provider);
12601         }
12602         ndr->depth--;
12603         ndr->depth--;
12604 }
12605
12606 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
12607 {
12608         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
12609 }
12610
12611 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
12612 {
12613         if (ndr_flags & NDR_SCALARS) {
12614                 NDR_CHECK(ndr_push_align(ndr, 8));
12615                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12616                 {
12617                         uint32_t _flags_save_string = ndr->flags;
12618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12619                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12620                         ndr->flags = _flags_save_string;
12621                 }
12622                 {
12623                         uint32_t _flags_save_string = ndr->flags;
12624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12625                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12626                         ndr->flags = _flags_save_string;
12627                 }
12628                 {
12629                         uint32_t _flags_save_string = ndr->flags;
12630                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12631                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12632                         ndr->flags = _flags_save_string;
12633                 }
12634                 {
12635                         uint32_t _flags_save_string = ndr->flags;
12636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12637                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12638                         ndr->flags = _flags_save_string;
12639                 }
12640                 {
12641                         uint32_t _flags_save_string = ndr->flags;
12642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12643                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12644                         ndr->flags = _flags_save_string;
12645                 }
12646                 {
12647                         uint32_t _flags_save_string = ndr->flags;
12648                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12649                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12650                         ndr->flags = _flags_save_string;
12651                 }
12652                 {
12653                         uint32_t _flags_save_string = ndr->flags;
12654                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12655                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12656                         ndr->flags = _flags_save_string;
12657                 }
12658                 {
12659                         uint32_t _flags_save_string = ndr->flags;
12660                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12661                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12662                         ndr->flags = _flags_save_string;
12663                 }
12664                 {
12665                         uint32_t _flags_save_string_array = ndr->flags;
12666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12667                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12668                         ndr->flags = _flags_save_string_array;
12669                 }
12670                 {
12671                         uint32_t _flags_save_string_array = ndr->flags;
12672                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12673                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12674                         ndr->flags = _flags_save_string_array;
12675                 }
12676                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12677                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12678                 {
12679                         uint32_t _flags_save_string = ndr->flags;
12680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12681                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12682                         ndr->flags = _flags_save_string;
12683                 }
12684                 {
12685                         uint32_t _flags_save_string = ndr->flags;
12686                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12687                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12688                         ndr->flags = _flags_save_string;
12689                 }
12690                 {
12691                         uint32_t _flags_save_string = ndr->flags;
12692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12693                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12694                         ndr->flags = _flags_save_string;
12695                 }
12696                 {
12697                         uint32_t _flags_save_string = ndr->flags;
12698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12699                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12700                         ndr->flags = _flags_save_string;
12701                 }
12702                 {
12703                         uint32_t _flags_save_string = ndr->flags;
12704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12705                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
12706                         ndr->flags = _flags_save_string;
12707                 }
12708                 {
12709                         uint32_t _flags_save_string = ndr->flags;
12710                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12711                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
12712                         ndr->flags = _flags_save_string;
12713                 }
12714                 {
12715                         uint32_t _flags_save_string_array = ndr->flags;
12716                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12717                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
12718                         ndr->flags = _flags_save_string_array;
12719                 }
12720                 {
12721                         uint32_t _flags_save_string = ndr->flags;
12722                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12723                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
12724                         ndr->flags = _flags_save_string;
12725                 }
12726                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
12727                 {
12728                         uint32_t _flags_save_string_array = ndr->flags;
12729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12730                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
12731                         ndr->flags = _flags_save_string_array;
12732                 }
12733                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
12734                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
12735         }
12736         if (ndr_flags & NDR_BUFFERS) {
12737                 {
12738                         uint32_t _flags_save_string = ndr->flags;
12739                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12740                         if (r->driver_name) {
12741                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
12742                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12743                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
12744                         }
12745                         ndr->flags = _flags_save_string;
12746                 }
12747                 {
12748                         uint32_t _flags_save_string = ndr->flags;
12749                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12750                         if (r->architecture) {
12751                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
12752                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12753                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
12754                         }
12755                         ndr->flags = _flags_save_string;
12756                 }
12757                 {
12758                         uint32_t _flags_save_string = ndr->flags;
12759                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12760                         if (r->driver_path) {
12761                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
12762                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12763                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
12764                         }
12765                         ndr->flags = _flags_save_string;
12766                 }
12767                 {
12768                         uint32_t _flags_save_string = ndr->flags;
12769                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12770                         if (r->data_file) {
12771                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
12772                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12773                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
12774                         }
12775                         ndr->flags = _flags_save_string;
12776                 }
12777                 {
12778                         uint32_t _flags_save_string = ndr->flags;
12779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12780                         if (r->config_file) {
12781                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
12782                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12783                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
12784                         }
12785                         ndr->flags = _flags_save_string;
12786                 }
12787                 {
12788                         uint32_t _flags_save_string = ndr->flags;
12789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12790                         if (r->help_file) {
12791                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
12792                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12793                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
12794                         }
12795                         ndr->flags = _flags_save_string;
12796                 }
12797                 {
12798                         uint32_t _flags_save_string = ndr->flags;
12799                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12800                         if (r->monitor_name) {
12801                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
12802                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12803                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
12804                         }
12805                         ndr->flags = _flags_save_string;
12806                 }
12807                 {
12808                         uint32_t _flags_save_string = ndr->flags;
12809                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12810                         if (r->default_datatype) {
12811                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
12812                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12813                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
12814                         }
12815                         ndr->flags = _flags_save_string;
12816                 }
12817                 {
12818                         uint32_t _flags_save_string_array = ndr->flags;
12819                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12820                         if (r->dependent_files) {
12821                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
12822                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12823                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
12824                         }
12825                         ndr->flags = _flags_save_string_array;
12826                 }
12827                 {
12828                         uint32_t _flags_save_string_array = ndr->flags;
12829                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12830                         if (r->previous_names) {
12831                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
12832                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12833                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
12834                         }
12835                         ndr->flags = _flags_save_string_array;
12836                 }
12837                 {
12838                         uint32_t _flags_save_string = ndr->flags;
12839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12840                         if (r->manufacturer_name) {
12841                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_name));
12842                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12843                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_name));
12844                         }
12845                         ndr->flags = _flags_save_string;
12846                 }
12847                 {
12848                         uint32_t _flags_save_string = ndr->flags;
12849                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12850                         if (r->manufacturer_url) {
12851                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_url));
12852                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12853                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_url));
12854                         }
12855                         ndr->flags = _flags_save_string;
12856                 }
12857                 {
12858                         uint32_t _flags_save_string = ndr->flags;
12859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12860                         if (r->hardware_id) {
12861                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->hardware_id));
12862                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12863                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->hardware_id));
12864                         }
12865                         ndr->flags = _flags_save_string;
12866                 }
12867                 {
12868                         uint32_t _flags_save_string = ndr->flags;
12869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12870                         if (r->provider) {
12871                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->provider));
12872                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12873                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->provider));
12874                         }
12875                         ndr->flags = _flags_save_string;
12876                 }
12877                 {
12878                         uint32_t _flags_save_string = ndr->flags;
12879                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12880                         if (r->print_processor) {
12881                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
12882                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
12883                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
12884                         }
12885                         ndr->flags = _flags_save_string;
12886                 }
12887                 {
12888                         uint32_t _flags_save_string = ndr->flags;
12889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12890                         if (r->vendor_setup) {
12891                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->vendor_setup));
12892                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
12893                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->vendor_setup));
12894                         }
12895                         ndr->flags = _flags_save_string;
12896                 }
12897                 {
12898                         uint32_t _flags_save_string_array = ndr->flags;
12899                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12900                         if (r->color_profiles) {
12901                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->color_profiles));
12902                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
12903                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->color_profiles));
12904                         }
12905                         ndr->flags = _flags_save_string_array;
12906                 }
12907                 {
12908                         uint32_t _flags_save_string = ndr->flags;
12909                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12910                         if (r->inf_path) {
12911                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->inf_path));
12912                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
12913                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->inf_path));
12914                         }
12915                         ndr->flags = _flags_save_string;
12916                 }
12917                 {
12918                         uint32_t _flags_save_string_array = ndr->flags;
12919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12920                         if (r->core_driver_dependencies) {
12921                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->core_driver_dependencies));
12922                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
12923                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->core_driver_dependencies));
12924                         }
12925                         ndr->flags = _flags_save_string_array;
12926                 }
12927         }
12928         return NDR_ERR_SUCCESS;
12929 }
12930
12931 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
12932 {
12933         uint32_t _ptr_driver_name;
12934         TALLOC_CTX *_mem_save_driver_name_0;
12935         uint32_t _ptr_architecture;
12936         TALLOC_CTX *_mem_save_architecture_0;
12937         uint32_t _ptr_driver_path;
12938         TALLOC_CTX *_mem_save_driver_path_0;
12939         uint32_t _ptr_data_file;
12940         TALLOC_CTX *_mem_save_data_file_0;
12941         uint32_t _ptr_config_file;
12942         TALLOC_CTX *_mem_save_config_file_0;
12943         uint32_t _ptr_help_file;
12944         TALLOC_CTX *_mem_save_help_file_0;
12945         uint32_t _ptr_monitor_name;
12946         TALLOC_CTX *_mem_save_monitor_name_0;
12947         uint32_t _ptr_default_datatype;
12948         TALLOC_CTX *_mem_save_default_datatype_0;
12949         uint32_t _ptr_dependent_files;
12950         TALLOC_CTX *_mem_save_dependent_files_0;
12951         uint32_t _ptr_previous_names;
12952         TALLOC_CTX *_mem_save_previous_names_0;
12953         uint32_t _ptr_manufacturer_name;
12954         TALLOC_CTX *_mem_save_manufacturer_name_0;
12955         uint32_t _ptr_manufacturer_url;
12956         TALLOC_CTX *_mem_save_manufacturer_url_0;
12957         uint32_t _ptr_hardware_id;
12958         TALLOC_CTX *_mem_save_hardware_id_0;
12959         uint32_t _ptr_provider;
12960         TALLOC_CTX *_mem_save_provider_0;
12961         uint32_t _ptr_print_processor;
12962         TALLOC_CTX *_mem_save_print_processor_0;
12963         uint32_t _ptr_vendor_setup;
12964         TALLOC_CTX *_mem_save_vendor_setup_0;
12965         uint32_t _ptr_color_profiles;
12966         TALLOC_CTX *_mem_save_color_profiles_0;
12967         uint32_t _ptr_inf_path;
12968         TALLOC_CTX *_mem_save_inf_path_0;
12969         uint32_t _ptr_core_driver_dependencies;
12970         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
12971         if (ndr_flags & NDR_SCALARS) {
12972                 NDR_CHECK(ndr_pull_align(ndr, 8));
12973                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12974                 {
12975                         uint32_t _flags_save_string = ndr->flags;
12976                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12977                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12978                         if (_ptr_driver_name) {
12979                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12980                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12981                         } else {
12982                                 r->driver_name = NULL;
12983                         }
12984                         ndr->flags = _flags_save_string;
12985                 }
12986                 {
12987                         uint32_t _flags_save_string = ndr->flags;
12988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12989                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12990                         if (_ptr_architecture) {
12991                                 NDR_PULL_ALLOC(ndr, r->architecture);
12992                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12993                         } else {
12994                                 r->architecture = NULL;
12995                         }
12996                         ndr->flags = _flags_save_string;
12997                 }
12998                 {
12999                         uint32_t _flags_save_string = ndr->flags;
13000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13001                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
13002                         if (_ptr_driver_path) {
13003                                 NDR_PULL_ALLOC(ndr, r->driver_path);
13004                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
13005                         } else {
13006                                 r->driver_path = NULL;
13007                         }
13008                         ndr->flags = _flags_save_string;
13009                 }
13010                 {
13011                         uint32_t _flags_save_string = ndr->flags;
13012                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13013                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
13014                         if (_ptr_data_file) {
13015                                 NDR_PULL_ALLOC(ndr, r->data_file);
13016                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
13017                         } else {
13018                                 r->data_file = NULL;
13019                         }
13020                         ndr->flags = _flags_save_string;
13021                 }
13022                 {
13023                         uint32_t _flags_save_string = ndr->flags;
13024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13025                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
13026                         if (_ptr_config_file) {
13027                                 NDR_PULL_ALLOC(ndr, r->config_file);
13028                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
13029                         } else {
13030                                 r->config_file = NULL;
13031                         }
13032                         ndr->flags = _flags_save_string;
13033                 }
13034                 {
13035                         uint32_t _flags_save_string = ndr->flags;
13036                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13037                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
13038                         if (_ptr_help_file) {
13039                                 NDR_PULL_ALLOC(ndr, r->help_file);
13040                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
13041                         } else {
13042                                 r->help_file = NULL;
13043                         }
13044                         ndr->flags = _flags_save_string;
13045                 }
13046                 {
13047                         uint32_t _flags_save_string = ndr->flags;
13048                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13049                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
13050                         if (_ptr_monitor_name) {
13051                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
13052                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
13053                         } else {
13054                                 r->monitor_name = NULL;
13055                         }
13056                         ndr->flags = _flags_save_string;
13057                 }
13058                 {
13059                         uint32_t _flags_save_string = ndr->flags;
13060                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13061                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
13062                         if (_ptr_default_datatype) {
13063                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
13064                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
13065                         } else {
13066                                 r->default_datatype = NULL;
13067                         }
13068                         ndr->flags = _flags_save_string;
13069                 }
13070                 {
13071                         uint32_t _flags_save_string_array = ndr->flags;
13072                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13073                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
13074                         if (_ptr_dependent_files) {
13075                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
13076                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
13077                         } else {
13078                                 r->dependent_files = NULL;
13079                         }
13080                         ndr->flags = _flags_save_string_array;
13081                 }
13082                 {
13083                         uint32_t _flags_save_string_array = ndr->flags;
13084                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13085                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
13086                         if (_ptr_previous_names) {
13087                                 NDR_PULL_ALLOC(ndr, r->previous_names);
13088                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
13089                         } else {
13090                                 r->previous_names = NULL;
13091                         }
13092                         ndr->flags = _flags_save_string_array;
13093                 }
13094                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
13095                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
13096                 {
13097                         uint32_t _flags_save_string = ndr->flags;
13098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13099                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
13100                         if (_ptr_manufacturer_name) {
13101                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
13102                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
13103                         } else {
13104                                 r->manufacturer_name = NULL;
13105                         }
13106                         ndr->flags = _flags_save_string;
13107                 }
13108                 {
13109                         uint32_t _flags_save_string = ndr->flags;
13110                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13111                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
13112                         if (_ptr_manufacturer_url) {
13113                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
13114                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
13115                         } else {
13116                                 r->manufacturer_url = NULL;
13117                         }
13118                         ndr->flags = _flags_save_string;
13119                 }
13120                 {
13121                         uint32_t _flags_save_string = ndr->flags;
13122                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13123                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
13124                         if (_ptr_hardware_id) {
13125                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
13126                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
13127                         } else {
13128                                 r->hardware_id = NULL;
13129                         }
13130                         ndr->flags = _flags_save_string;
13131                 }
13132                 {
13133                         uint32_t _flags_save_string = ndr->flags;
13134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13135                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
13136                         if (_ptr_provider) {
13137                                 NDR_PULL_ALLOC(ndr, r->provider);
13138                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
13139                         } else {
13140                                 r->provider = NULL;
13141                         }
13142                         ndr->flags = _flags_save_string;
13143                 }
13144                 {
13145                         uint32_t _flags_save_string = ndr->flags;
13146                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13147                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
13148                         if (_ptr_print_processor) {
13149                                 NDR_PULL_ALLOC(ndr, r->print_processor);
13150                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
13151                         } else {
13152                                 r->print_processor = NULL;
13153                         }
13154                         ndr->flags = _flags_save_string;
13155                 }
13156                 {
13157                         uint32_t _flags_save_string = ndr->flags;
13158                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13159                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
13160                         if (_ptr_vendor_setup) {
13161                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
13162                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
13163                         } else {
13164                                 r->vendor_setup = NULL;
13165                         }
13166                         ndr->flags = _flags_save_string;
13167                 }
13168                 {
13169                         uint32_t _flags_save_string_array = ndr->flags;
13170                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13171                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
13172                         if (_ptr_color_profiles) {
13173                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
13174                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
13175                         } else {
13176                                 r->color_profiles = NULL;
13177                         }
13178                         ndr->flags = _flags_save_string_array;
13179                 }
13180                 {
13181                         uint32_t _flags_save_string = ndr->flags;
13182                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13183                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
13184                         if (_ptr_inf_path) {
13185                                 NDR_PULL_ALLOC(ndr, r->inf_path);
13186                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
13187                         } else {
13188                                 r->inf_path = NULL;
13189                         }
13190                         ndr->flags = _flags_save_string;
13191                 }
13192                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
13193                 {
13194                         uint32_t _flags_save_string_array = ndr->flags;
13195                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13196                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
13197                         if (_ptr_core_driver_dependencies) {
13198                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
13199                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
13200                         } else {
13201                                 r->core_driver_dependencies = NULL;
13202                         }
13203                         ndr->flags = _flags_save_string_array;
13204                 }
13205                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
13206                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
13207         }
13208         if (ndr_flags & NDR_BUFFERS) {
13209                 {
13210                         uint32_t _flags_save_string = ndr->flags;
13211                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13212                         if (r->driver_name) {
13213                                 uint32_t _relative_save_offset;
13214                                 _relative_save_offset = ndr->offset;
13215                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13216                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13217                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13218                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13219                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13220                                 ndr->offset = _relative_save_offset;
13221                         }
13222                         ndr->flags = _flags_save_string;
13223                 }
13224                 {
13225                         uint32_t _flags_save_string = ndr->flags;
13226                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13227                         if (r->architecture) {
13228                                 uint32_t _relative_save_offset;
13229                                 _relative_save_offset = ndr->offset;
13230                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
13231                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
13232                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
13233                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
13234                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
13235                                 ndr->offset = _relative_save_offset;
13236                         }
13237                         ndr->flags = _flags_save_string;
13238                 }
13239                 {
13240                         uint32_t _flags_save_string = ndr->flags;
13241                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13242                         if (r->driver_path) {
13243                                 uint32_t _relative_save_offset;
13244                                 _relative_save_offset = ndr->offset;
13245                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
13246                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13247                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
13248                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
13249                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
13250                                 ndr->offset = _relative_save_offset;
13251                         }
13252                         ndr->flags = _flags_save_string;
13253                 }
13254                 {
13255                         uint32_t _flags_save_string = ndr->flags;
13256                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13257                         if (r->data_file) {
13258                                 uint32_t _relative_save_offset;
13259                                 _relative_save_offset = ndr->offset;
13260                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
13261                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13262                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
13263                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
13264                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
13265                                 ndr->offset = _relative_save_offset;
13266                         }
13267                         ndr->flags = _flags_save_string;
13268                 }
13269                 {
13270                         uint32_t _flags_save_string = ndr->flags;
13271                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13272                         if (r->config_file) {
13273                                 uint32_t _relative_save_offset;
13274                                 _relative_save_offset = ndr->offset;
13275                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
13276                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13277                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
13278                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
13279                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
13280                                 ndr->offset = _relative_save_offset;
13281                         }
13282                         ndr->flags = _flags_save_string;
13283                 }
13284                 {
13285                         uint32_t _flags_save_string = ndr->flags;
13286                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13287                         if (r->help_file) {
13288                                 uint32_t _relative_save_offset;
13289                                 _relative_save_offset = ndr->offset;
13290                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
13291                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13292                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
13293                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
13294                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
13295                                 ndr->offset = _relative_save_offset;
13296                         }
13297                         ndr->flags = _flags_save_string;
13298                 }
13299                 {
13300                         uint32_t _flags_save_string = ndr->flags;
13301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13302                         if (r->monitor_name) {
13303                                 uint32_t _relative_save_offset;
13304                                 _relative_save_offset = ndr->offset;
13305                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
13306                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13307                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
13308                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
13309                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
13310                                 ndr->offset = _relative_save_offset;
13311                         }
13312                         ndr->flags = _flags_save_string;
13313                 }
13314                 {
13315                         uint32_t _flags_save_string = ndr->flags;
13316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13317                         if (r->default_datatype) {
13318                                 uint32_t _relative_save_offset;
13319                                 _relative_save_offset = ndr->offset;
13320                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
13321                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
13322                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
13323                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
13324                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
13325                                 ndr->offset = _relative_save_offset;
13326                         }
13327                         ndr->flags = _flags_save_string;
13328                 }
13329                 {
13330                         uint32_t _flags_save_string_array = ndr->flags;
13331                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13332                         if (r->dependent_files) {
13333                                 uint32_t _relative_save_offset;
13334                                 _relative_save_offset = ndr->offset;
13335                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
13336                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
13337                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
13338                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
13339                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
13340                                 ndr->offset = _relative_save_offset;
13341                         }
13342                         ndr->flags = _flags_save_string_array;
13343                 }
13344                 {
13345                         uint32_t _flags_save_string_array = ndr->flags;
13346                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13347                         if (r->previous_names) {
13348                                 uint32_t _relative_save_offset;
13349                                 _relative_save_offset = ndr->offset;
13350                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
13351                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
13352                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
13353                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
13354                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
13355                                 ndr->offset = _relative_save_offset;
13356                         }
13357                         ndr->flags = _flags_save_string_array;
13358                 }
13359                 {
13360                         uint32_t _flags_save_string = ndr->flags;
13361                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13362                         if (r->manufacturer_name) {
13363                                 uint32_t _relative_save_offset;
13364                                 _relative_save_offset = ndr->offset;
13365                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
13366                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13367                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
13368                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
13369                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
13370                                 ndr->offset = _relative_save_offset;
13371                         }
13372                         ndr->flags = _flags_save_string;
13373                 }
13374                 {
13375                         uint32_t _flags_save_string = ndr->flags;
13376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13377                         if (r->manufacturer_url) {
13378                                 uint32_t _relative_save_offset;
13379                                 _relative_save_offset = ndr->offset;
13380                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
13381                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
13382                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
13383                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
13384                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13385                                 ndr->offset = _relative_save_offset;
13386                         }
13387                         ndr->flags = _flags_save_string;
13388                 }
13389                 {
13390                         uint32_t _flags_save_string = ndr->flags;
13391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13392                         if (r->hardware_id) {
13393                                 uint32_t _relative_save_offset;
13394                                 _relative_save_offset = ndr->offset;
13395                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13396                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13397                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13398                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13399                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13400                                 ndr->offset = _relative_save_offset;
13401                         }
13402                         ndr->flags = _flags_save_string;
13403                 }
13404                 {
13405                         uint32_t _flags_save_string = ndr->flags;
13406                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13407                         if (r->provider) {
13408                                 uint32_t _relative_save_offset;
13409                                 _relative_save_offset = ndr->offset;
13410                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13411                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13412                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13413                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13414                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13415                                 ndr->offset = _relative_save_offset;
13416                         }
13417                         ndr->flags = _flags_save_string;
13418                 }
13419                 {
13420                         uint32_t _flags_save_string = ndr->flags;
13421                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13422                         if (r->print_processor) {
13423                                 uint32_t _relative_save_offset;
13424                                 _relative_save_offset = ndr->offset;
13425                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
13426                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
13427                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
13428                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
13429                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
13430                                 ndr->offset = _relative_save_offset;
13431                         }
13432                         ndr->flags = _flags_save_string;
13433                 }
13434                 {
13435                         uint32_t _flags_save_string = ndr->flags;
13436                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13437                         if (r->vendor_setup) {
13438                                 uint32_t _relative_save_offset;
13439                                 _relative_save_offset = ndr->offset;
13440                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
13441                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
13442                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
13443                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
13444                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
13445                                 ndr->offset = _relative_save_offset;
13446                         }
13447                         ndr->flags = _flags_save_string;
13448                 }
13449                 {
13450                         uint32_t _flags_save_string_array = ndr->flags;
13451                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13452                         if (r->color_profiles) {
13453                                 uint32_t _relative_save_offset;
13454                                 _relative_save_offset = ndr->offset;
13455                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
13456                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
13457                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
13458                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
13459                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
13460                                 ndr->offset = _relative_save_offset;
13461                         }
13462                         ndr->flags = _flags_save_string_array;
13463                 }
13464                 {
13465                         uint32_t _flags_save_string = ndr->flags;
13466                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13467                         if (r->inf_path) {
13468                                 uint32_t _relative_save_offset;
13469                                 _relative_save_offset = ndr->offset;
13470                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
13471                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13472                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
13473                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
13474                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
13475                                 ndr->offset = _relative_save_offset;
13476                         }
13477                         ndr->flags = _flags_save_string;
13478                 }
13479                 {
13480                         uint32_t _flags_save_string_array = ndr->flags;
13481                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13482                         if (r->core_driver_dependencies) {
13483                                 uint32_t _relative_save_offset;
13484                                 _relative_save_offset = ndr->offset;
13485                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
13486                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13487                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
13488                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
13489                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
13490                                 ndr->offset = _relative_save_offset;
13491                         }
13492                         ndr->flags = _flags_save_string_array;
13493                 }
13494         }
13495         return NDR_ERR_SUCCESS;
13496 }
13497
13498 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
13499 {
13500         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
13501         ndr->depth++;
13502         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13503         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13504         ndr->depth++;
13505         if (r->driver_name) {
13506                 ndr_print_string(ndr, "driver_name", r->driver_name);
13507         }
13508         ndr->depth--;
13509         ndr_print_ptr(ndr, "architecture", r->architecture);
13510         ndr->depth++;
13511         if (r->architecture) {
13512                 ndr_print_string(ndr, "architecture", r->architecture);
13513         }
13514         ndr->depth--;
13515         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13516         ndr->depth++;
13517         if (r->driver_path) {
13518                 ndr_print_string(ndr, "driver_path", r->driver_path);
13519         }
13520         ndr->depth--;
13521         ndr_print_ptr(ndr, "data_file", r->data_file);
13522         ndr->depth++;
13523         if (r->data_file) {
13524                 ndr_print_string(ndr, "data_file", r->data_file);
13525         }
13526         ndr->depth--;
13527         ndr_print_ptr(ndr, "config_file", r->config_file);
13528         ndr->depth++;
13529         if (r->config_file) {
13530                 ndr_print_string(ndr, "config_file", r->config_file);
13531         }
13532         ndr->depth--;
13533         ndr_print_ptr(ndr, "help_file", r->help_file);
13534         ndr->depth++;
13535         if (r->help_file) {
13536                 ndr_print_string(ndr, "help_file", r->help_file);
13537         }
13538         ndr->depth--;
13539         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13540         ndr->depth++;
13541         if (r->monitor_name) {
13542                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13543         }
13544         ndr->depth--;
13545         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13546         ndr->depth++;
13547         if (r->default_datatype) {
13548                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13549         }
13550         ndr->depth--;
13551         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13552         ndr->depth++;
13553         if (r->dependent_files) {
13554                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13555         }
13556         ndr->depth--;
13557         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13558         ndr->depth++;
13559         if (r->previous_names) {
13560                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13561         }
13562         ndr->depth--;
13563         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13564         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13565         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13566         ndr->depth++;
13567         if (r->manufacturer_name) {
13568                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13569         }
13570         ndr->depth--;
13571         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13572         ndr->depth++;
13573         if (r->manufacturer_url) {
13574                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13575         }
13576         ndr->depth--;
13577         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13578         ndr->depth++;
13579         if (r->hardware_id) {
13580                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13581         }
13582         ndr->depth--;
13583         ndr_print_ptr(ndr, "provider", r->provider);
13584         ndr->depth++;
13585         if (r->provider) {
13586                 ndr_print_string(ndr, "provider", r->provider);
13587         }
13588         ndr->depth--;
13589         ndr_print_ptr(ndr, "print_processor", r->print_processor);
13590         ndr->depth++;
13591         if (r->print_processor) {
13592                 ndr_print_string(ndr, "print_processor", r->print_processor);
13593         }
13594         ndr->depth--;
13595         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
13596         ndr->depth++;
13597         if (r->vendor_setup) {
13598                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
13599         }
13600         ndr->depth--;
13601         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
13602         ndr->depth++;
13603         if (r->color_profiles) {
13604                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
13605         }
13606         ndr->depth--;
13607         ndr_print_ptr(ndr, "inf_path", r->inf_path);
13608         ndr->depth++;
13609         if (r->inf_path) {
13610                 ndr_print_string(ndr, "inf_path", r->inf_path);
13611         }
13612         ndr->depth--;
13613         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
13614         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13615         ndr->depth++;
13616         if (r->core_driver_dependencies) {
13617                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13618         }
13619         ndr->depth--;
13620         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
13621         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
13622         ndr->depth--;
13623 }
13624
13625 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
13626 {
13627         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
13628 }
13629
13630 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
13631 {
13632         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13633         return NDR_ERR_SUCCESS;
13634 }
13635
13636 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
13637 {
13638         uint32_t v;
13639         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13640         *r = v;
13641         return NDR_ERR_SUCCESS;
13642 }
13643
13644 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
13645 {
13646         const char *val = NULL;
13647
13648         switch (r) {
13649                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
13650                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
13651                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
13652                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
13653                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
13654         }
13655         ndr_print_enum(ndr, name, "ENUM", val, r);
13656 }
13657
13658 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
13659 {
13660         if (ndr_flags & NDR_SCALARS) {
13661                 NDR_CHECK(ndr_push_align(ndr, 4));
13662                 {
13663                         uint32_t _flags_save_string = ndr->flags;
13664                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13665                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
13666                         ndr->flags = _flags_save_string;
13667                 }
13668                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
13669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
13670         }
13671         if (ndr_flags & NDR_BUFFERS) {
13672                 {
13673                         uint32_t _flags_save_string = ndr->flags;
13674                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13675                         if (r->file_name) {
13676                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->file_name));
13677                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
13678                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->file_name));
13679                         }
13680                         ndr->flags = _flags_save_string;
13681                 }
13682         }
13683         return NDR_ERR_SUCCESS;
13684 }
13685
13686 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
13687 {
13688         uint32_t _ptr_file_name;
13689         TALLOC_CTX *_mem_save_file_name_0;
13690         if (ndr_flags & NDR_SCALARS) {
13691                 NDR_CHECK(ndr_pull_align(ndr, 4));
13692                 {
13693                         uint32_t _flags_save_string = ndr->flags;
13694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13695                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
13696                         if (_ptr_file_name) {
13697                                 NDR_PULL_ALLOC(ndr, r->file_name);
13698                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
13699                         } else {
13700                                 r->file_name = NULL;
13701                         }
13702                         ndr->flags = _flags_save_string;
13703                 }
13704                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
13705                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
13706         }
13707         if (ndr_flags & NDR_BUFFERS) {
13708                 {
13709                         uint32_t _flags_save_string = ndr->flags;
13710                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13711                         if (r->file_name) {
13712                                 uint32_t _relative_save_offset;
13713                                 _relative_save_offset = ndr->offset;
13714                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
13715                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13716                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
13717                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
13718                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
13719                                 ndr->offset = _relative_save_offset;
13720                         }
13721                         ndr->flags = _flags_save_string;
13722                 }
13723         }
13724         return NDR_ERR_SUCCESS;
13725 }
13726
13727 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
13728 {
13729         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
13730         ndr->depth++;
13731         ndr_print_ptr(ndr, "file_name", r->file_name);
13732         ndr->depth++;
13733         if (r->file_name) {
13734                 ndr_print_string(ndr, "file_name", r->file_name);
13735         }
13736         ndr->depth--;
13737         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
13738         ndr_print_uint32(ndr, "file_version", r->file_version);
13739         ndr->depth--;
13740 }
13741
13742 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
13743 {
13744         uint32_t cntr_file_info_1;
13745         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
13746         ndr->depth++;
13747         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13748         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13749         ndr->depth++;
13750         if (r->driver_name) {
13751                 ndr_print_string(ndr, "driver_name", r->driver_name);
13752         }
13753         ndr->depth--;
13754         ndr_print_ptr(ndr, "architecture", r->architecture);
13755         ndr->depth++;
13756         if (r->architecture) {
13757                 ndr_print_string(ndr, "architecture", r->architecture);
13758         }
13759         ndr->depth--;
13760         ndr_print_ptr(ndr, "file_info", r->file_info);
13761         ndr->depth++;
13762         if (r->file_info) {
13763                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
13764                 ndr->depth++;
13765                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
13766                         char *idx_1=NULL;
13767                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
13768                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
13769                                 free(idx_1);
13770                         }
13771                 }
13772                 ndr->depth--;
13773         }
13774         ndr->depth--;
13775         ndr_print_uint32(ndr, "file_count", r->file_count);
13776         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13777         ndr->depth++;
13778         if (r->monitor_name) {
13779                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13780         }
13781         ndr->depth--;
13782         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13783         ndr->depth++;
13784         if (r->default_datatype) {
13785                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13786         }
13787         ndr->depth--;
13788         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13789         ndr->depth++;
13790         if (r->previous_names) {
13791                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13792         }
13793         ndr->depth--;
13794         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13795         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13796         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13797         ndr->depth++;
13798         if (r->manufacturer_name) {
13799                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13800         }
13801         ndr->depth--;
13802         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13803         ndr->depth++;
13804         if (r->manufacturer_url) {
13805                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13806         }
13807         ndr->depth--;
13808         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13809         ndr->depth++;
13810         if (r->hardware_id) {
13811                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13812         }
13813         ndr->depth--;
13814         ndr_print_ptr(ndr, "provider", r->provider);
13815         ndr->depth++;
13816         if (r->provider) {
13817                 ndr_print_string(ndr, "provider", r->provider);
13818         }
13819         ndr->depth--;
13820         ndr->depth--;
13821 }
13822
13823 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
13824 {
13825         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
13826 }
13827
13828 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
13829 {
13830         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13831         {
13832                 uint32_t _flags_save_UNION = ndr->flags;
13833                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
13834                 if (ndr_flags & NDR_SCALARS) {
13835                         int level = ndr_push_get_switch_value(ndr, r);
13836                         switch (level) {
13837                                 case 1: {
13838                                         NDR_CHECK(ndr_push_align(ndr, 4));
13839                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13840                                         NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13841                                 break; }
13842
13843                                 case 2: {
13844                                         NDR_CHECK(ndr_push_align(ndr, 4));
13845                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13846                                         NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13847                                 break; }
13848
13849                                 case 3: {
13850                                         NDR_CHECK(ndr_push_align(ndr, 4));
13851                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13852                                         NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13853                                 break; }
13854
13855                                 case 4: {
13856                                         NDR_CHECK(ndr_push_align(ndr, 4));
13857                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13858                                         NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13859                                 break; }
13860
13861                                 case 5: {
13862                                         NDR_CHECK(ndr_push_align(ndr, 4));
13863                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13864                                         NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13865                                 break; }
13866
13867                                 case 6: {
13868                                         NDR_CHECK(ndr_push_align(ndr, 8));
13869                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13870                                         NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13871                                 break; }
13872
13873                                 case 8: {
13874                                         NDR_CHECK(ndr_push_align(ndr, 8));
13875                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13876                                         NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13877                                 break; }
13878
13879                                 case 101: {
13880                                         NDR_CHECK(ndr_push_align(ndr, 8));
13881                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13882                                         NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13883                                 break; }
13884
13885                                 default: {
13886                                 break; }
13887
13888                         }
13889                 }
13890                 if (ndr_flags & NDR_BUFFERS) {
13891                         int level = ndr_push_get_switch_value(ndr, r);
13892                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13893                         switch (level) {
13894                                 case 1:
13895                                         NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13896                                 break;
13897
13898                                 case 2:
13899                                         NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13900                                 break;
13901
13902                                 case 3:
13903                                         NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13904                                 break;
13905
13906                                 case 4:
13907                                         NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13908                                 break;
13909
13910                                 case 5:
13911                                         NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13912                                 break;
13913
13914                                 case 6:
13915                                         NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13916                                 break;
13917
13918                                 case 8:
13919                                         NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13920                                 break;
13921
13922                                 case 101:
13923                                         NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13924                                 break;
13925
13926                                 default:
13927                                 break;
13928
13929                         }
13930                 }
13931                 ndr->flags = _flags_save_UNION;
13932         }
13933         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13934         return NDR_ERR_SUCCESS;
13935 }
13936
13937 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
13938 {
13939         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13940         int level;
13941         {
13942                 uint32_t _flags_save_UNION = ndr->flags;
13943                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
13944                 level = ndr_pull_get_switch_value(ndr, r);
13945                 if (ndr_flags & NDR_SCALARS) {
13946                         switch (level) {
13947                                 case 1: {
13948                                         NDR_CHECK(ndr_pull_align(ndr, 4));
13949                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13950                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13951                                 break; }
13952
13953                                 case 2: {
13954                                         NDR_CHECK(ndr_pull_align(ndr, 4));
13955                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13956                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13957                                 break; }
13958
13959                                 case 3: {
13960                                         NDR_CHECK(ndr_pull_align(ndr, 4));
13961                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13962                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13963                                 break; }
13964
13965                                 case 4: {
13966                                         NDR_CHECK(ndr_pull_align(ndr, 4));
13967                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13968                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13969                                 break; }
13970
13971                                 case 5: {
13972                                         NDR_CHECK(ndr_pull_align(ndr, 4));
13973                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13974                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13975                                 break; }
13976
13977                                 case 6: {
13978                                         NDR_CHECK(ndr_pull_align(ndr, 8));
13979                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13980                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13981                                 break; }
13982
13983                                 case 8: {
13984                                         NDR_CHECK(ndr_pull_align(ndr, 8));
13985                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13986                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13987                                 break; }
13988
13989                                 case 101: {
13990                                         NDR_CHECK(ndr_pull_align(ndr, 8));
13991                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13992                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13993                                 break; }
13994
13995                                 default: {
13996                                 break; }
13997
13998                         }
13999                 }
14000                 if (ndr_flags & NDR_BUFFERS) {
14001                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14002                         switch (level) {
14003                                 case 1:
14004                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14005                                 break;
14006
14007                                 case 2:
14008                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14009                                 break;
14010
14011                                 case 3:
14012                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14013                                 break;
14014
14015                                 case 4:
14016                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14017                                 break;
14018
14019                                 case 5:
14020                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14021                                 break;
14022
14023                                 case 6:
14024                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14025                                 break;
14026
14027                                 case 8:
14028                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14029                                 break;
14030
14031                                 case 101:
14032                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14033                                 break;
14034
14035                                 default:
14036                                 break;
14037
14038                         }
14039                 }
14040                 ndr->flags = _flags_save_UNION;
14041         }
14042         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14043         return NDR_ERR_SUCCESS;
14044 }
14045
14046 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
14047 {
14048         int level;
14049         {
14050                 uint32_t _flags_save_UNION = ndr->flags;
14051                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14052                 level = ndr_print_get_switch_value(ndr, r);
14053                 ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
14054                 switch (level) {
14055                         case 1:
14056                                 ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
14057                         break;
14058
14059                         case 2:
14060                                 ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
14061                         break;
14062
14063                         case 3:
14064                                 ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
14065                         break;
14066
14067                         case 4:
14068                                 ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
14069                         break;
14070
14071                         case 5:
14072                                 ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
14073                         break;
14074
14075                         case 6:
14076                                 ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
14077                         break;
14078
14079                         case 8:
14080                                 ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
14081                         break;
14082
14083                         case 101:
14084                                 ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
14085                         break;
14086
14087                         default:
14088                         break;
14089
14090                 }
14091                 ndr->flags = _flags_save_UNION;
14092         }
14093 }
14094
14095 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14096 {
14097         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
14098         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
14099 }
14100
14101 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
14102 {
14103         if (ndr_flags & NDR_SCALARS) {
14104                 NDR_CHECK(ndr_push_align(ndr, 4));
14105                 {
14106                         uint32_t _flags_save_string = ndr->flags;
14107                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14108                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14109                         ndr->flags = _flags_save_string;
14110                 }
14111         }
14112         if (ndr_flags & NDR_BUFFERS) {
14113         }
14114         return NDR_ERR_SUCCESS;
14115 }
14116
14117 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
14118 {
14119         if (ndr_flags & NDR_SCALARS) {
14120                 NDR_CHECK(ndr_pull_align(ndr, 4));
14121                 {
14122                         uint32_t _flags_save_string = ndr->flags;
14123                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14124                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14125                         ndr->flags = _flags_save_string;
14126                 }
14127         }
14128         if (ndr_flags & NDR_BUFFERS) {
14129         }
14130         return NDR_ERR_SUCCESS;
14131 }
14132
14133 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
14134 {
14135         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
14136         ndr->depth++;
14137         ndr_print_string(ndr, "directory_name", r->directory_name);
14138         ndr->depth--;
14139 }
14140
14141 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14142 {
14143         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
14144 }
14145
14146 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
14147 {
14148         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14149         {
14150                 uint32_t _flags_save_UNION = ndr->flags;
14151                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14152                 if (ndr_flags & NDR_SCALARS) {
14153                         int level = ndr_push_get_switch_value(ndr, r);
14154                         switch (level) {
14155                                 case 1: {
14156                                         NDR_CHECK(ndr_push_align(ndr, 4));
14157                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14158                                         NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14159                                 break; }
14160
14161                                 default: {
14162                                         NDR_CHECK(ndr_push_align(ndr, 4));
14163                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14164                                         NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14165                                 break; }
14166
14167                         }
14168                 }
14169                 if (ndr_flags & NDR_BUFFERS) {
14170                         int level = ndr_push_get_switch_value(ndr, r);
14171                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14172                         switch (level) {
14173                                 case 1:
14174                                 break;
14175
14176                                 default:
14177                                 break;
14178
14179                         }
14180                 }
14181                 ndr->flags = _flags_save_UNION;
14182         }
14183         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14184         return NDR_ERR_SUCCESS;
14185 }
14186
14187 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
14188 {
14189         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14190         int level;
14191         {
14192                 uint32_t _flags_save_UNION = ndr->flags;
14193                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14194                 level = ndr_pull_get_switch_value(ndr, r);
14195                 if (ndr_flags & NDR_SCALARS) {
14196                         switch (level) {
14197                                 case 1: {
14198                                         NDR_CHECK(ndr_pull_align(ndr, 4));
14199                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14200                                         NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14201                                 break; }
14202
14203                                 default: {
14204                                         NDR_CHECK(ndr_pull_align(ndr, 4));
14205                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14206                                         NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14207                                 break; }
14208
14209                         }
14210                 }
14211                 if (ndr_flags & NDR_BUFFERS) {
14212                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14213                         switch (level) {
14214                                 case 1:
14215                                 break;
14216
14217                                 default:
14218                                 break;
14219
14220                         }
14221                 }
14222                 ndr->flags = _flags_save_UNION;
14223         }
14224         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14225         return NDR_ERR_SUCCESS;
14226 }
14227
14228 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
14229 {
14230         int level;
14231         {
14232                 uint32_t _flags_save_UNION = ndr->flags;
14233                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14234                 level = ndr_print_get_switch_value(ndr, r);
14235                 ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
14236                 switch (level) {
14237                         case 1:
14238                                 ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
14239                         break;
14240
14241                         default:
14242                                 ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
14243                         break;
14244
14245                 }
14246                 ndr->flags = _flags_save_UNION;
14247         }
14248 }
14249
14250 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14251 {
14252         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
14253         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
14254 }
14255
14256 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
14257 {
14258         if (ndr_flags & NDR_SCALARS) {
14259                 NDR_CHECK(ndr_push_align(ndr, 4));
14260                 {
14261                         uint32_t _flags_save_string = ndr->flags;
14262                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14263                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
14264                         ndr->flags = _flags_save_string;
14265                 }
14266         }
14267         if (ndr_flags & NDR_BUFFERS) {
14268                 {
14269                         uint32_t _flags_save_string = ndr->flags;
14270                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14271                         if (r->print_processor_name) {
14272                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor_name));
14273                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
14274                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor_name));
14275                         }
14276                         ndr->flags = _flags_save_string;
14277                 }
14278         }
14279         return NDR_ERR_SUCCESS;
14280 }
14281
14282 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
14283 {
14284         uint32_t _ptr_print_processor_name;
14285         TALLOC_CTX *_mem_save_print_processor_name_0;
14286         if (ndr_flags & NDR_SCALARS) {
14287                 NDR_CHECK(ndr_pull_align(ndr, 4));
14288                 {
14289                         uint32_t _flags_save_string = ndr->flags;
14290                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14291                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
14292                         if (_ptr_print_processor_name) {
14293                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
14294                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
14295                         } else {
14296                                 r->print_processor_name = NULL;
14297                         }
14298                         ndr->flags = _flags_save_string;
14299                 }
14300         }
14301         if (ndr_flags & NDR_BUFFERS) {
14302                 {
14303                         uint32_t _flags_save_string = ndr->flags;
14304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14305                         if (r->print_processor_name) {
14306                                 uint32_t _relative_save_offset;
14307                                 _relative_save_offset = ndr->offset;
14308                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
14309                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14310                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
14311                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
14312                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
14313                                 ndr->offset = _relative_save_offset;
14314                         }
14315                         ndr->flags = _flags_save_string;
14316                 }
14317         }
14318         return NDR_ERR_SUCCESS;
14319 }
14320
14321 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
14322 {
14323         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
14324         ndr->depth++;
14325         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
14326         ndr->depth++;
14327         if (r->print_processor_name) {
14328                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
14329         }
14330         ndr->depth--;
14331         ndr->depth--;
14332 }
14333
14334 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14335 {
14336         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
14337 }
14338
14339 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
14340 {
14341         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14342         {
14343                 uint32_t _flags_save_UNION = ndr->flags;
14344                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14345                 if (ndr_flags & NDR_SCALARS) {
14346                         int level = ndr_push_get_switch_value(ndr, r);
14347                         switch (level) {
14348                                 case 1: {
14349                                         NDR_CHECK(ndr_push_align(ndr, 4));
14350                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14351                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
14352                                 break; }
14353
14354                                 default: {
14355                                 break; }
14356
14357                         }
14358                 }
14359                 if (ndr_flags & NDR_BUFFERS) {
14360                         int level = ndr_push_get_switch_value(ndr, r);
14361                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14362                         switch (level) {
14363                                 case 1:
14364                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
14365                                 break;
14366
14367                                 default:
14368                                 break;
14369
14370                         }
14371                 }
14372                 ndr->flags = _flags_save_UNION;
14373         }
14374         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14375         return NDR_ERR_SUCCESS;
14376 }
14377
14378 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
14379 {
14380         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14381         int level;
14382         {
14383                 uint32_t _flags_save_UNION = ndr->flags;
14384                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14385                 level = ndr_pull_get_switch_value(ndr, r);
14386                 if (ndr_flags & NDR_SCALARS) {
14387                         switch (level) {
14388                                 case 1: {
14389                                         NDR_CHECK(ndr_pull_align(ndr, 4));
14390                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14391                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
14392                                 break; }
14393
14394                                 default: {
14395                                 break; }
14396
14397                         }
14398                 }
14399                 if (ndr_flags & NDR_BUFFERS) {
14400                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14401                         switch (level) {
14402                                 case 1:
14403                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
14404                                 break;
14405
14406                                 default:
14407                                 break;
14408
14409                         }
14410                 }
14411                 ndr->flags = _flags_save_UNION;
14412         }
14413         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14414         return NDR_ERR_SUCCESS;
14415 }
14416
14417 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
14418 {
14419         int level;
14420         {
14421                 uint32_t _flags_save_UNION = ndr->flags;
14422                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14423                 level = ndr_print_get_switch_value(ndr, r);
14424                 ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
14425                 switch (level) {
14426                         case 1:
14427                                 ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
14428                         break;
14429
14430                         default:
14431                         break;
14432
14433                 }
14434                 ndr->flags = _flags_save_UNION;
14435         }
14436 }
14437
14438 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14439 {
14440         if (ndr_flags & NDR_SCALARS) {
14441                 NDR_CHECK(ndr_push_align(ndr, 4));
14442                 {
14443                         uint32_t _flags_save_string = ndr->flags;
14444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14445                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14446                         ndr->flags = _flags_save_string;
14447                 }
14448         }
14449         if (ndr_flags & NDR_BUFFERS) {
14450         }
14451         return NDR_ERR_SUCCESS;
14452 }
14453
14454 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
14455 {
14456         if (ndr_flags & NDR_SCALARS) {
14457                 NDR_CHECK(ndr_pull_align(ndr, 4));
14458                 {
14459                         uint32_t _flags_save_string = ndr->flags;
14460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14461                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14462                         ndr->flags = _flags_save_string;
14463                 }
14464         }
14465         if (ndr_flags & NDR_BUFFERS) {
14466         }
14467         return NDR_ERR_SUCCESS;
14468 }
14469
14470 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14471 {
14472         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
14473         ndr->depth++;
14474         ndr_print_string(ndr, "directory_name", r->directory_name);
14475         ndr->depth--;
14476 }
14477
14478 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14479 {
14480         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
14481 }
14482
14483 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
14484 {
14485         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14486         {
14487                 uint32_t _flags_save_UNION = ndr->flags;
14488                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14489                 if (ndr_flags & NDR_SCALARS) {
14490                         int level = ndr_push_get_switch_value(ndr, r);
14491                         switch (level) {
14492                                 case 1: {
14493                                         NDR_CHECK(ndr_push_align(ndr, 4));
14494                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14495                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14496                                 break; }
14497
14498                                 default: {
14499                                         NDR_CHECK(ndr_push_align(ndr, 4));
14500                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14501                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14502                                 break; }
14503
14504                         }
14505                 }
14506                 if (ndr_flags & NDR_BUFFERS) {
14507                         int level = ndr_push_get_switch_value(ndr, r);
14508                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14509                         switch (level) {
14510                                 case 1:
14511                                 break;
14512
14513                                 default:
14514                                 break;
14515
14516                         }
14517                 }
14518                 ndr->flags = _flags_save_UNION;
14519         }
14520         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14521         return NDR_ERR_SUCCESS;
14522 }
14523
14524 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
14525 {
14526         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14527         int level;
14528         {
14529                 uint32_t _flags_save_UNION = ndr->flags;
14530                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14531                 level = ndr_pull_get_switch_value(ndr, r);
14532                 if (ndr_flags & NDR_SCALARS) {
14533                         switch (level) {
14534                                 case 1: {
14535                                         NDR_CHECK(ndr_pull_align(ndr, 4));
14536                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14537                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14538                                 break; }
14539
14540                                 default: {
14541                                         NDR_CHECK(ndr_pull_align(ndr, 4));
14542                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14543                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14544                                 break; }
14545
14546                         }
14547                 }
14548                 if (ndr_flags & NDR_BUFFERS) {
14549                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14550                         switch (level) {
14551                                 case 1:
14552                                 break;
14553
14554                                 default:
14555                                 break;
14556
14557                         }
14558                 }
14559                 ndr->flags = _flags_save_UNION;
14560         }
14561         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14562         return NDR_ERR_SUCCESS;
14563 }
14564
14565 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
14566 {
14567         int level;
14568         {
14569                 uint32_t _flags_save_UNION = ndr->flags;
14570                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14571                 level = ndr_print_get_switch_value(ndr, r);
14572                 ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
14573                 switch (level) {
14574                         case 1:
14575                                 ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14576                         break;
14577
14578                         default:
14579                                 ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14580                         break;
14581
14582                 }
14583                 ndr->flags = _flags_save_UNION;
14584         }
14585 }
14586
14587 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14588 {
14589         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
14590         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
14591 }
14592
14593 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
14594 {
14595         if (ndr_flags & NDR_SCALARS) {
14596                 NDR_CHECK(ndr_push_align(ndr, 4));
14597                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
14598                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
14599                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
14600         }
14601         if (ndr_flags & NDR_BUFFERS) {
14602                 if (r->document_name) {
14603                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14604                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14605                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14606                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14607                 }
14608                 if (r->output_file) {
14609                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14610                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14611                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14612                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14613                 }
14614                 if (r->datatype) {
14615                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14616                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14617                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14618                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14619                 }
14620         }
14621         return NDR_ERR_SUCCESS;
14622 }
14623
14624 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
14625 {
14626         uint32_t _ptr_document_name;
14627         TALLOC_CTX *_mem_save_document_name_0;
14628         uint32_t _ptr_output_file;
14629         TALLOC_CTX *_mem_save_output_file_0;
14630         uint32_t _ptr_datatype;
14631         TALLOC_CTX *_mem_save_datatype_0;
14632         if (ndr_flags & NDR_SCALARS) {
14633                 NDR_CHECK(ndr_pull_align(ndr, 4));
14634                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
14635                 if (_ptr_document_name) {
14636                         NDR_PULL_ALLOC(ndr, r->document_name);
14637                 } else {
14638                         r->document_name = NULL;
14639                 }
14640                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
14641                 if (_ptr_output_file) {
14642                         NDR_PULL_ALLOC(ndr, r->output_file);
14643                 } else {
14644                         r->output_file = NULL;
14645                 }
14646                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14647                 if (_ptr_datatype) {
14648                         NDR_PULL_ALLOC(ndr, r->datatype);
14649                 } else {
14650                         r->datatype = NULL;
14651                 }
14652         }
14653         if (ndr_flags & NDR_BUFFERS) {
14654                 if (r->document_name) {
14655                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14656                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
14657                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
14658                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
14659                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
14660                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
14661                         }
14662                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
14663                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
14664                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
14665                 }
14666                 if (r->output_file) {
14667                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14668                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
14669                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
14670                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
14671                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
14672                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->output_file), ndr_get_array_length(ndr, &r->output_file));
14673                         }
14674                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
14675                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
14676                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
14677                 }
14678                 if (r->datatype) {
14679                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14680                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
14681                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
14682                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
14683                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
14684                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
14685                         }
14686                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
14687                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
14688                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14689                 }
14690         }
14691         return NDR_ERR_SUCCESS;
14692 }
14693
14694 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
14695 {
14696         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
14697         ndr->depth++;
14698         ndr_print_ptr(ndr, "document_name", r->document_name);
14699         ndr->depth++;
14700         if (r->document_name) {
14701                 ndr_print_string(ndr, "document_name", r->document_name);
14702         }
14703         ndr->depth--;
14704         ndr_print_ptr(ndr, "output_file", r->output_file);
14705         ndr->depth++;
14706         if (r->output_file) {
14707                 ndr_print_string(ndr, "output_file", r->output_file);
14708         }
14709         ndr->depth--;
14710         ndr_print_ptr(ndr, "datatype", r->datatype);
14711         ndr->depth++;
14712         if (r->datatype) {
14713                 ndr_print_string(ndr, "datatype", r->datatype);
14714         }
14715         ndr->depth--;
14716         ndr->depth--;
14717 }
14718
14719 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
14720 {
14721         if (ndr_flags & NDR_SCALARS) {
14722                 int level = ndr_push_get_switch_value(ndr, r);
14723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14724                 switch (level) {
14725                         case 1: {
14726                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
14727                         break; }
14728
14729                         case 2: {
14730                         break; }
14731
14732                         case 3: {
14733                         break; }
14734
14735                         default: {
14736                         break; }
14737
14738                 }
14739         }
14740         if (ndr_flags & NDR_BUFFERS) {
14741                 int level = ndr_push_get_switch_value(ndr, r);
14742                 switch (level) {
14743                         case 1:
14744                                 if (r->info1) {
14745                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14746                                 }
14747                         break;
14748
14749                         case 2:
14750                         break;
14751
14752                         case 3:
14753                         break;
14754
14755                         default:
14756                         break;
14757
14758                 }
14759         }
14760         return NDR_ERR_SUCCESS;
14761 }
14762
14763 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
14764 {
14765         int level;
14766         uint32_t _level;
14767         TALLOC_CTX *_mem_save_info1_0;
14768         level = ndr_pull_get_switch_value(ndr, r);
14769         if (ndr_flags & NDR_SCALARS) {
14770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14771                 if (_level != level) {
14772                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14773                 }
14774                 switch (level) {
14775                         case 1: {
14776                                 uint32_t _ptr_info1;
14777                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
14778                                 if (_ptr_info1) {
14779                                         NDR_PULL_ALLOC(ndr, r->info1);
14780                                 } else {
14781                                         r->info1 = NULL;
14782                                 }
14783                         break; }
14784
14785                         case 2: {
14786                         break; }
14787
14788                         case 3: {
14789                         break; }
14790
14791                         default: {
14792                         break; }
14793
14794                 }
14795         }
14796         if (ndr_flags & NDR_BUFFERS) {
14797                 switch (level) {
14798                         case 1:
14799                                 if (r->info1) {
14800                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14801                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
14802                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14803                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
14804                                 }
14805                         break;
14806
14807                         case 2:
14808                         break;
14809
14810                         case 3:
14811                         break;
14812
14813                         default:
14814                         break;
14815
14816                 }
14817         }
14818         return NDR_ERR_SUCCESS;
14819 }
14820
14821 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
14822 {
14823         int level;
14824         level = ndr_print_get_switch_value(ndr, r);
14825         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
14826         switch (level) {
14827                 case 1:
14828                         ndr_print_ptr(ndr, "info1", r->info1);
14829                         ndr->depth++;
14830                         if (r->info1) {
14831                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
14832                         }
14833                         ndr->depth--;
14834                 break;
14835
14836                 case 2:
14837                 break;
14838
14839                 case 3:
14840                 break;
14841
14842                 default:
14843                 break;
14844
14845         }
14846 }
14847
14848 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
14849 {
14850         if (ndr_flags & NDR_SCALARS) {
14851                 NDR_CHECK(ndr_push_align(ndr, 4));
14852                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
14853                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14854                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14855                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14856                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14857                 {
14858                         uint32_t _flags_save_string = ndr->flags;
14859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14860                         {
14861                                 struct ndr_push *_ndr_extra_string;
14862                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14863                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14864                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14865                         }
14866                         ndr->flags = _flags_save_string;
14867                 }
14868         }
14869         if (ndr_flags & NDR_BUFFERS) {
14870         }
14871         return NDR_ERR_SUCCESS;
14872 }
14873
14874 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
14875 {
14876         if (ndr_flags & NDR_SCALARS) {
14877                 NDR_CHECK(ndr_pull_align(ndr, 4));
14878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14879                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14880                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14882                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
14883                 {
14884                         uint32_t _flags_save_string = ndr->flags;
14885                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14886                         {
14887                                 struct ndr_pull *_ndr_extra_string;
14888                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14889                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14890                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14891                         }
14892                         ndr->flags = _flags_save_string;
14893                 }
14894         }
14895         if (ndr_flags & NDR_BUFFERS) {
14896         }
14897         return NDR_ERR_SUCCESS;
14898 }
14899
14900 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
14901 {
14902         ndr_print_struct(ndr, name, "spoolss_OSVersion");
14903         ndr->depth++;
14904         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
14905         ndr_print_uint32(ndr, "major", r->major);
14906         ndr_print_uint32(ndr, "minor", r->minor);
14907         ndr_print_uint32(ndr, "build", r->build);
14908         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
14909         ndr_print_string(ndr, "extra_string", r->extra_string);
14910         ndr->depth--;
14911 }
14912
14913 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
14914 {
14915         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
14916 }
14917
14918 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
14919 {
14920         if (ndr_flags & NDR_SCALARS) {
14921                 NDR_CHECK(ndr_push_align(ndr, 4));
14922                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
14923                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14924                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14925                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14926                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14927                 {
14928                         uint32_t _flags_save_string = ndr->flags;
14929                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14930                         {
14931                                 struct ndr_push *_ndr_extra_string;
14932                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14933                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14934                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14935                         }
14936                         ndr->flags = _flags_save_string;
14937                 }
14938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
14939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
14940         }
14941         if (ndr_flags & NDR_BUFFERS) {
14942         }
14943         return NDR_ERR_SUCCESS;
14944 }
14945
14946 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
14947 {
14948         if (ndr_flags & NDR_SCALARS) {
14949                 NDR_CHECK(ndr_pull_align(ndr, 4));
14950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14951                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14952                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14953                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14954                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
14955                 {
14956                         uint32_t _flags_save_string = ndr->flags;
14957                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14958                         {
14959                                 struct ndr_pull *_ndr_extra_string;
14960                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14961                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14962                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14963                         }
14964                         ndr->flags = _flags_save_string;
14965                 }
14966                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
14967                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
14968         }
14969         if (ndr_flags & NDR_BUFFERS) {
14970         }
14971         return NDR_ERR_SUCCESS;
14972 }
14973
14974 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
14975 {
14976         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
14977         ndr->depth++;
14978         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
14979         ndr_print_uint32(ndr, "major", r->major);
14980         ndr_print_uint32(ndr, "minor", r->minor);
14981         ndr_print_uint32(ndr, "build", r->build);
14982         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
14983         ndr_print_string(ndr, "extra_string", r->extra_string);
14984         ndr_print_uint32(ndr, "unknown2", r->unknown2);
14985         ndr_print_uint32(ndr, "unknown3", r->unknown3);
14986         ndr->depth--;
14987 }
14988
14989 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
14990 {
14991         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
14992 }
14993
14994 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
14995 {
14996         if (ndr_flags & NDR_SCALARS) {
14997                 int level = ndr_push_get_switch_value(ndr, r);
14998                 switch (level) {
14999                         case REG_NONE: {
15000                         break; }
15001
15002                         case REG_SZ: {
15003                                 {
15004                                         uint32_t _flags_save_string = ndr->flags;
15005                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15006                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
15007                                         ndr->flags = _flags_save_string;
15008                                 }
15009                         break; }
15010
15011                         case REG_BINARY: {
15012                                 {
15013                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15014                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15015                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
15016                                         ndr->flags = _flags_save_DATA_BLOB;
15017                                 }
15018                         break; }
15019
15020                         case REG_DWORD: {
15021                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
15022                         break; }
15023
15024                         case REG_MULTI_SZ: {
15025                                 {
15026                                         uint32_t _flags_save_string_array = ndr->flags;
15027                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15028                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
15029                                         ndr->flags = _flags_save_string_array;
15030                                 }
15031                         break; }
15032
15033                         default: {
15034                                 {
15035                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15036                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15037                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
15038                                         ndr->flags = _flags_save_DATA_BLOB;
15039                                 }
15040                         break; }
15041
15042                 }
15043         }
15044         if (ndr_flags & NDR_BUFFERS) {
15045                 int level = ndr_push_get_switch_value(ndr, r);
15046                 switch (level) {
15047                         case REG_NONE:
15048                         break;
15049
15050                         case REG_SZ:
15051                         break;
15052
15053                         case REG_BINARY:
15054                         break;
15055
15056                         case REG_DWORD:
15057                         break;
15058
15059                         case REG_MULTI_SZ:
15060                         break;
15061
15062                         default:
15063                         break;
15064
15065                 }
15066         }
15067         return NDR_ERR_SUCCESS;
15068 }
15069
15070 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
15071 {
15072         int level;
15073         level = ndr_pull_get_switch_value(ndr, r);
15074         if (ndr_flags & NDR_SCALARS) {
15075                 switch (level) {
15076                         case REG_NONE: {
15077                         break; }
15078
15079                         case REG_SZ: {
15080                                 {
15081                                         uint32_t _flags_save_string = ndr->flags;
15082                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15083                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
15084                                         ndr->flags = _flags_save_string;
15085                                 }
15086                         break; }
15087
15088                         case REG_BINARY: {
15089                                 {
15090                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15091                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15092                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
15093                                         ndr->flags = _flags_save_DATA_BLOB;
15094                                 }
15095                         break; }
15096
15097                         case REG_DWORD: {
15098                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
15099                         break; }
15100
15101                         case REG_MULTI_SZ: {
15102                                 {
15103                                         uint32_t _flags_save_string_array = ndr->flags;
15104                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15105                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
15106                                         ndr->flags = _flags_save_string_array;
15107                                 }
15108                         break; }
15109
15110                         default: {
15111                                 {
15112                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15113                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15114                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
15115                                         ndr->flags = _flags_save_DATA_BLOB;
15116                                 }
15117                         break; }
15118
15119                 }
15120         }
15121         if (ndr_flags & NDR_BUFFERS) {
15122                 switch (level) {
15123                         case REG_NONE:
15124                         break;
15125
15126                         case REG_SZ:
15127                         break;
15128
15129                         case REG_BINARY:
15130                         break;
15131
15132                         case REG_DWORD:
15133                         break;
15134
15135                         case REG_MULTI_SZ:
15136                         break;
15137
15138                         default:
15139                         break;
15140
15141                 }
15142         }
15143         return NDR_ERR_SUCCESS;
15144 }
15145
15146 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
15147 {
15148         int level;
15149         level = ndr_print_get_switch_value(ndr, r);
15150         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
15151         switch (level) {
15152                 case REG_NONE:
15153                 break;
15154
15155                 case REG_SZ:
15156                         ndr_print_string(ndr, "string", r->string);
15157                 break;
15158
15159                 case REG_BINARY:
15160                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
15161                 break;
15162
15163                 case REG_DWORD:
15164                         ndr_print_uint32(ndr, "value", r->value);
15165                 break;
15166
15167                 case REG_MULTI_SZ:
15168                         ndr_print_string_array(ndr, "string_array", r->string_array);
15169                 break;
15170
15171                 default:
15172                         ndr_print_DATA_BLOB(ndr, "data", r->data);
15173                 break;
15174
15175         }
15176 }
15177
15178 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15179 {
15180         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
15181 }
15182
15183 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
15184 {
15185         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15186         return NDR_ERR_SUCCESS;
15187 }
15188
15189 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
15190 {
15191         uint32_t v;
15192         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15193         *r = v;
15194         return NDR_ERR_SUCCESS;
15195 }
15196
15197 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
15198 {
15199         const char *val = NULL;
15200
15201         switch (r) {
15202                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
15203                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
15204                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
15205         }
15206         ndr_print_enum(ndr, name, "ENUM", val, r);
15207 }
15208
15209 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
15210 {
15211         if (ndr_flags & NDR_SCALARS) {
15212                 NDR_CHECK(ndr_push_align(ndr, 4));
15213                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
15214                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
15215         }
15216         if (ndr_flags & NDR_BUFFERS) {
15217         }
15218         return NDR_ERR_SUCCESS;
15219 }
15220
15221 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
15222 {
15223         if (ndr_flags & NDR_SCALARS) {
15224                 NDR_CHECK(ndr_pull_align(ndr, 4));
15225                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
15226                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
15227         }
15228         if (ndr_flags & NDR_BUFFERS) {
15229         }
15230         return NDR_ERR_SUCCESS;
15231 }
15232
15233 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
15234 {
15235         ndr_print_struct(ndr, name, "spoolss_FormSize");
15236         ndr->depth++;
15237         ndr_print_uint32(ndr, "width", r->width);
15238         ndr_print_uint32(ndr, "height", r->height);
15239         ndr->depth--;
15240 }
15241
15242 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
15243 {
15244         if (ndr_flags & NDR_SCALARS) {
15245                 NDR_CHECK(ndr_push_align(ndr, 4));
15246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
15247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
15248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
15249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
15250         }
15251         if (ndr_flags & NDR_BUFFERS) {
15252         }
15253         return NDR_ERR_SUCCESS;
15254 }
15255
15256 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
15257 {
15258         if (ndr_flags & NDR_SCALARS) {
15259                 NDR_CHECK(ndr_pull_align(ndr, 4));
15260                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
15261                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
15262                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
15263                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
15264         }
15265         if (ndr_flags & NDR_BUFFERS) {
15266         }
15267         return NDR_ERR_SUCCESS;
15268 }
15269
15270 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
15271 {
15272         ndr_print_struct(ndr, name, "spoolss_FormArea");
15273         ndr->depth++;
15274         ndr_print_uint32(ndr, "left", r->left);
15275         ndr_print_uint32(ndr, "top", r->top);
15276         ndr_print_uint32(ndr, "right", r->right);
15277         ndr_print_uint32(ndr, "bottom", r->bottom);
15278         ndr->depth--;
15279 }
15280
15281 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
15282 {
15283         if (ndr_flags & NDR_SCALARS) {
15284                 NDR_CHECK(ndr_push_align(ndr, 4));
15285                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15286                 {
15287                         uint32_t _flags_save_string = ndr->flags;
15288                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15289                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
15290                         ndr->flags = _flags_save_string;
15291                 }
15292                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15293                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15294         }
15295         if (ndr_flags & NDR_BUFFERS) {
15296                 {
15297                         uint32_t _flags_save_string = ndr->flags;
15298                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15299                         if (r->form_name) {
15300                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->form_name));
15301                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
15302                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->form_name));
15303                         }
15304                         ndr->flags = _flags_save_string;
15305                 }
15306         }
15307         return NDR_ERR_SUCCESS;
15308 }
15309
15310 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
15311 {
15312         uint32_t _ptr_form_name;
15313         TALLOC_CTX *_mem_save_form_name_0;
15314         if (ndr_flags & NDR_SCALARS) {
15315                 NDR_CHECK(ndr_pull_align(ndr, 4));
15316                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15317                 {
15318                         uint32_t _flags_save_string = ndr->flags;
15319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15320                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15321                         if (_ptr_form_name) {
15322                                 NDR_PULL_ALLOC(ndr, r->form_name);
15323                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15324                         } else {
15325                                 r->form_name = NULL;
15326                         }
15327                         ndr->flags = _flags_save_string;
15328                 }
15329                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15330                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15331         }
15332         if (ndr_flags & NDR_BUFFERS) {
15333                 {
15334                         uint32_t _flags_save_string = ndr->flags;
15335                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15336                         if (r->form_name) {
15337                                 uint32_t _relative_save_offset;
15338                                 _relative_save_offset = ndr->offset;
15339                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15340                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15341                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15342                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15343                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15344                                 ndr->offset = _relative_save_offset;
15345                         }
15346                         ndr->flags = _flags_save_string;
15347                 }
15348         }
15349         return NDR_ERR_SUCCESS;
15350 }
15351
15352 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
15353 {
15354         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
15355         ndr->depth++;
15356         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15357         ndr_print_ptr(ndr, "form_name", r->form_name);
15358         ndr->depth++;
15359         if (r->form_name) {
15360                 ndr_print_string(ndr, "form_name", r->form_name);
15361         }
15362         ndr->depth--;
15363         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15364         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15365         ndr->depth--;
15366 }
15367
15368 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15369 {
15370         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
15371 }
15372
15373 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15374 {
15375         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15376         return NDR_ERR_SUCCESS;
15377 }
15378
15379 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15380 {
15381         uint32_t v;
15382         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15383         *r = v;
15384         return NDR_ERR_SUCCESS;
15385 }
15386
15387 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
15388 {
15389         ndr_print_uint32(ndr, name, r);
15390         ndr->depth++;
15391         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
15392         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
15393         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
15394         ndr->depth--;
15395 }
15396
15397 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
15398 {
15399         if (ndr_flags & NDR_SCALARS) {
15400                 NDR_CHECK(ndr_push_align(ndr, 4));
15401                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15402                 {
15403                         uint32_t _flags_save_string = ndr->flags;
15404                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15405                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
15406                         ndr->flags = _flags_save_string;
15407                 }
15408                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15409                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15410                 {
15411                         uint32_t _flags_save_string = ndr->flags;
15412                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15413                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
15414                         ndr->flags = _flags_save_string;
15415                 }
15416                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15417                 {
15418                         uint32_t _flags_save_string = ndr->flags;
15419                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15420                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
15421                         ndr->flags = _flags_save_string;
15422                 }
15423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15424                 {
15425                         uint32_t _flags_save_string = ndr->flags;
15426                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15427                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
15428                         ndr->flags = _flags_save_string;
15429                 }
15430                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15431         }
15432         if (ndr_flags & NDR_BUFFERS) {
15433                 {
15434                         uint32_t _flags_save_string = ndr->flags;
15435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15436                         if (r->form_name) {
15437                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->form_name));
15438                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
15439                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->form_name));
15440                         }
15441                         ndr->flags = _flags_save_string;
15442                 }
15443                 {
15444                         uint32_t _flags_save_string = ndr->flags;
15445                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15446                         if (r->keyword) {
15447                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->keyword));
15448                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
15449                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->keyword));
15450                         }
15451                         ndr->flags = _flags_save_string;
15452                 }
15453                 {
15454                         uint32_t _flags_save_string = ndr->flags;
15455                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15456                         if (r->mui_dll) {
15457                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->mui_dll));
15458                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
15459                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->mui_dll));
15460                         }
15461                         ndr->flags = _flags_save_string;
15462                 }
15463                 {
15464                         uint32_t _flags_save_string = ndr->flags;
15465                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15466                         if (r->display_name) {
15467                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->display_name));
15468                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
15469                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->display_name));
15470                         }
15471                         ndr->flags = _flags_save_string;
15472                 }
15473         }
15474         return NDR_ERR_SUCCESS;
15475 }
15476
15477 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
15478 {
15479         uint32_t _ptr_form_name;
15480         TALLOC_CTX *_mem_save_form_name_0;
15481         uint32_t _ptr_keyword;
15482         TALLOC_CTX *_mem_save_keyword_0;
15483         uint32_t _ptr_mui_dll;
15484         TALLOC_CTX *_mem_save_mui_dll_0;
15485         uint32_t _ptr_display_name;
15486         TALLOC_CTX *_mem_save_display_name_0;
15487         if (ndr_flags & NDR_SCALARS) {
15488                 NDR_CHECK(ndr_pull_align(ndr, 4));
15489                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15490                 {
15491                         uint32_t _flags_save_string = ndr->flags;
15492                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15493                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15494                         if (_ptr_form_name) {
15495                                 NDR_PULL_ALLOC(ndr, r->form_name);
15496                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15497                         } else {
15498                                 r->form_name = NULL;
15499                         }
15500                         ndr->flags = _flags_save_string;
15501                 }
15502                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15503                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15504                 {
15505                         uint32_t _flags_save_string = ndr->flags;
15506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15507                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15508                         if (_ptr_keyword) {
15509                                 NDR_PULL_ALLOC(ndr, r->keyword);
15510                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
15511                         } else {
15512                                 r->keyword = NULL;
15513                         }
15514                         ndr->flags = _flags_save_string;
15515                 }
15516                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15517                 {
15518                         uint32_t _flags_save_string = ndr->flags;
15519                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15520                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15521                         if (_ptr_mui_dll) {
15522                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
15523                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
15524                         } else {
15525                                 r->mui_dll = NULL;
15526                         }
15527                         ndr->flags = _flags_save_string;
15528                 }
15529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15530                 {
15531                         uint32_t _flags_save_string = ndr->flags;
15532                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15533                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15534                         if (_ptr_display_name) {
15535                                 NDR_PULL_ALLOC(ndr, r->display_name);
15536                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
15537                         } else {
15538                                 r->display_name = NULL;
15539                         }
15540                         ndr->flags = _flags_save_string;
15541                 }
15542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15543         }
15544         if (ndr_flags & NDR_BUFFERS) {
15545                 {
15546                         uint32_t _flags_save_string = ndr->flags;
15547                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15548                         if (r->form_name) {
15549                                 uint32_t _relative_save_offset;
15550                                 _relative_save_offset = ndr->offset;
15551                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15552                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15553                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15554                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15555                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15556                                 ndr->offset = _relative_save_offset;
15557                         }
15558                         ndr->flags = _flags_save_string;
15559                 }
15560                 {
15561                         uint32_t _flags_save_string = ndr->flags;
15562                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15563                         if (r->keyword) {
15564                                 uint32_t _relative_save_offset;
15565                                 _relative_save_offset = ndr->offset;
15566                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
15567                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15568                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15569                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
15570                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15571                                 ndr->offset = _relative_save_offset;
15572                         }
15573                         ndr->flags = _flags_save_string;
15574                 }
15575                 {
15576                         uint32_t _flags_save_string = ndr->flags;
15577                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15578                         if (r->mui_dll) {
15579                                 uint32_t _relative_save_offset;
15580                                 _relative_save_offset = ndr->offset;
15581                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
15582                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15583                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15584                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
15585                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15586                                 ndr->offset = _relative_save_offset;
15587                         }
15588                         ndr->flags = _flags_save_string;
15589                 }
15590                 {
15591                         uint32_t _flags_save_string = ndr->flags;
15592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15593                         if (r->display_name) {
15594                                 uint32_t _relative_save_offset;
15595                                 _relative_save_offset = ndr->offset;
15596                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
15597                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15598                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15599                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
15600                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15601                                 ndr->offset = _relative_save_offset;
15602                         }
15603                         ndr->flags = _flags_save_string;
15604                 }
15605         }
15606         return NDR_ERR_SUCCESS;
15607 }
15608
15609 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
15610 {
15611         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
15612         ndr->depth++;
15613         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15614         ndr_print_ptr(ndr, "form_name", r->form_name);
15615         ndr->depth++;
15616         if (r->form_name) {
15617                 ndr_print_string(ndr, "form_name", r->form_name);
15618         }
15619         ndr->depth--;
15620         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15621         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15622         ndr_print_ptr(ndr, "keyword", r->keyword);
15623         ndr->depth++;
15624         if (r->keyword) {
15625                 ndr_print_string(ndr, "keyword", r->keyword);
15626         }
15627         ndr->depth--;
15628         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15629         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15630         ndr->depth++;
15631         if (r->mui_dll) {
15632                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15633         }
15634         ndr->depth--;
15635         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15636         ndr_print_ptr(ndr, "display_name", r->display_name);
15637         ndr->depth++;
15638         if (r->display_name) {
15639                 ndr_print_string(ndr, "display_name", r->display_name);
15640         }
15641         ndr->depth--;
15642         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15643         ndr->depth--;
15644 }
15645
15646 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15647 {
15648         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
15649 }
15650
15651 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
15652 {
15653         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15654         {
15655                 uint32_t _flags_save_UNION = ndr->flags;
15656                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15657                 if (ndr_flags & NDR_SCALARS) {
15658                         int level = ndr_push_get_switch_value(ndr, r);
15659                         switch (level) {
15660                                 case 1: {
15661                                         NDR_CHECK(ndr_push_align(ndr, 4));
15662                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15663                                         NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15664                                 break; }
15665
15666                                 case 2: {
15667                                         NDR_CHECK(ndr_push_align(ndr, 4));
15668                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15669                                         NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15670                                 break; }
15671
15672                                 default: {
15673                                 break; }
15674
15675                         }
15676                 }
15677                 if (ndr_flags & NDR_BUFFERS) {
15678                         int level = ndr_push_get_switch_value(ndr, r);
15679                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15680                         switch (level) {
15681                                 case 1:
15682                                         NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15683                                 break;
15684
15685                                 case 2:
15686                                         NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15687                                 break;
15688
15689                                 default:
15690                                 break;
15691
15692                         }
15693                 }
15694                 ndr->flags = _flags_save_UNION;
15695         }
15696         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15697         return NDR_ERR_SUCCESS;
15698 }
15699
15700 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
15701 {
15702         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15703         int level;
15704         {
15705                 uint32_t _flags_save_UNION = ndr->flags;
15706                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15707                 level = ndr_pull_get_switch_value(ndr, r);
15708                 if (ndr_flags & NDR_SCALARS) {
15709                         switch (level) {
15710                                 case 1: {
15711                                         NDR_CHECK(ndr_pull_align(ndr, 4));
15712                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15713                                         NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15714                                 break; }
15715
15716                                 case 2: {
15717                                         NDR_CHECK(ndr_pull_align(ndr, 4));
15718                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15719                                         NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15720                                 break; }
15721
15722                                 default: {
15723                                 break; }
15724
15725                         }
15726                 }
15727                 if (ndr_flags & NDR_BUFFERS) {
15728                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15729                         switch (level) {
15730                                 case 1:
15731                                         NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15732                                 break;
15733
15734                                 case 2:
15735                                         NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15736                                 break;
15737
15738                                 default:
15739                                 break;
15740
15741                         }
15742                 }
15743                 ndr->flags = _flags_save_UNION;
15744         }
15745         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15746         return NDR_ERR_SUCCESS;
15747 }
15748
15749 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
15750 {
15751         int level;
15752         {
15753                 uint32_t _flags_save_UNION = ndr->flags;
15754                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15755                 level = ndr_print_get_switch_value(ndr, r);
15756                 ndr_print_union(ndr, name, level, "spoolss_FormInfo");
15757                 switch (level) {
15758                         case 1:
15759                                 ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
15760                         break;
15761
15762                         case 2:
15763                                 ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
15764                         break;
15765
15766                         default:
15767                         break;
15768
15769                 }
15770                 ndr->flags = _flags_save_UNION;
15771         }
15772 }
15773
15774 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15775 {
15776         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
15777         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
15778 }
15779
15780 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
15781 {
15782         if (ndr_flags & NDR_SCALARS) {
15783                 NDR_CHECK(ndr_push_align(ndr, 4));
15784                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15785                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15786                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15787                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15788         }
15789         if (ndr_flags & NDR_BUFFERS) {
15790                 if (r->form_name) {
15791                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15792                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15793                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15794                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15795                 }
15796         }
15797         return NDR_ERR_SUCCESS;
15798 }
15799
15800 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
15801 {
15802         uint32_t _ptr_form_name;
15803         TALLOC_CTX *_mem_save_form_name_0;
15804         if (ndr_flags & NDR_SCALARS) {
15805                 NDR_CHECK(ndr_pull_align(ndr, 4));
15806                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15807                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15808                 if (_ptr_form_name) {
15809                         NDR_PULL_ALLOC(ndr, r->form_name);
15810                 } else {
15811                         r->form_name = NULL;
15812                 }
15813                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15814                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15815         }
15816         if (ndr_flags & NDR_BUFFERS) {
15817                 if (r->form_name) {
15818                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15819                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15820                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15821                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15822                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15823                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->form_name), ndr_get_array_length(ndr, &r->form_name));
15824                         }
15825                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15826                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15827                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15828                 }
15829         }
15830         return NDR_ERR_SUCCESS;
15831 }
15832
15833 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
15834 {
15835         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
15836         ndr->depth++;
15837         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15838         ndr_print_ptr(ndr, "form_name", r->form_name);
15839         ndr->depth++;
15840         if (r->form_name) {
15841                 ndr_print_string(ndr, "form_name", r->form_name);
15842         }
15843         ndr->depth--;
15844         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15845         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15846         ndr->depth--;
15847 }
15848
15849 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
15850 {
15851         if (ndr_flags & NDR_SCALARS) {
15852                 NDR_CHECK(ndr_push_align(ndr, 4));
15853                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15854                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15855                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15856                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15857                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
15858                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15859                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
15860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15861                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
15862                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15863         }
15864         if (ndr_flags & NDR_BUFFERS) {
15865                 if (r->form_name) {
15866                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15867                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15868                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15869                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15870                 }
15871                 if (r->keyword) {
15872                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15873                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15874                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15875                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
15876                 }
15877                 if (r->mui_dll) {
15878                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15879                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15880                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15881                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15882                 }
15883                 if (r->display_name) {
15884                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15885                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15886                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15887                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15888                 }
15889         }
15890         return NDR_ERR_SUCCESS;
15891 }
15892
15893 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
15894 {
15895         uint32_t _ptr_form_name;
15896         TALLOC_CTX *_mem_save_form_name_0;
15897         uint32_t _ptr_keyword;
15898         TALLOC_CTX *_mem_save_keyword_0;
15899         uint32_t _ptr_mui_dll;
15900         TALLOC_CTX *_mem_save_mui_dll_0;
15901         uint32_t _ptr_display_name;
15902         TALLOC_CTX *_mem_save_display_name_0;
15903         if (ndr_flags & NDR_SCALARS) {
15904                 NDR_CHECK(ndr_pull_align(ndr, 4));
15905                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15906                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15907                 if (_ptr_form_name) {
15908                         NDR_PULL_ALLOC(ndr, r->form_name);
15909                 } else {
15910                         r->form_name = NULL;
15911                 }
15912                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15913                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15914                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15915                 if (_ptr_keyword) {
15916                         NDR_PULL_ALLOC(ndr, r->keyword);
15917                 } else {
15918                         r->keyword = NULL;
15919                 }
15920                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15921                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15922                 if (_ptr_mui_dll) {
15923                         NDR_PULL_ALLOC(ndr, r->mui_dll);
15924                 } else {
15925                         r->mui_dll = NULL;
15926                 }
15927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15928                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15929                 if (_ptr_display_name) {
15930                         NDR_PULL_ALLOC(ndr, r->display_name);
15931                 } else {
15932                         r->display_name = NULL;
15933                 }
15934                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15935         }
15936         if (ndr_flags & NDR_BUFFERS) {
15937                 if (r->form_name) {
15938                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15939                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15940                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15941                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15942                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15943                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->form_name), ndr_get_array_length(ndr, &r->form_name));
15944                         }
15945                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15946                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15947                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15948                 }
15949                 if (r->keyword) {
15950                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15951                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15952                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
15953                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
15954                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
15955                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->keyword), ndr_get_array_length(ndr, &r->keyword));
15956                         }
15957                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
15958                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
15959                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15960                 }
15961                 if (r->mui_dll) {
15962                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15963                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15964                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
15965                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
15966                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
15967                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->mui_dll), ndr_get_array_length(ndr, &r->mui_dll));
15968                         }
15969                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
15970                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
15971                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15972                 }
15973                 if (r->display_name) {
15974                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15975                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15976                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
15977                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
15978                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
15979                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->display_name), ndr_get_array_length(ndr, &r->display_name));
15980                         }
15981                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
15982                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
15983                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15984                 }
15985         }
15986         return NDR_ERR_SUCCESS;
15987 }
15988
15989 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
15990 {
15991         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
15992         ndr->depth++;
15993         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15994         ndr_print_ptr(ndr, "form_name", r->form_name);
15995         ndr->depth++;
15996         if (r->form_name) {
15997                 ndr_print_string(ndr, "form_name", r->form_name);
15998         }
15999         ndr->depth--;
16000         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16001         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16002         ndr_print_ptr(ndr, "keyword", r->keyword);
16003         ndr->depth++;
16004         if (r->keyword) {
16005                 ndr_print_string(ndr, "keyword", r->keyword);
16006         }
16007         ndr->depth--;
16008         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16009         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16010         ndr->depth++;
16011         if (r->mui_dll) {
16012                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16013         }
16014         ndr->depth--;
16015         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16016         ndr_print_ptr(ndr, "display_name", r->display_name);
16017         ndr->depth++;
16018         if (r->display_name) {
16019                 ndr_print_string(ndr, "display_name", r->display_name);
16020         }
16021         ndr->depth--;
16022         ndr_print_uint32(ndr, "lang_id", r->lang_id);
16023         ndr->depth--;
16024 }
16025
16026 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
16027 {
16028         if (ndr_flags & NDR_SCALARS) {
16029                 int level = ndr_push_get_switch_value(ndr, r);
16030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
16031                 switch (level) {
16032                         case 1: {
16033                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
16034                         break; }
16035
16036                         case 2: {
16037                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
16038                         break; }
16039
16040                         default:
16041                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
16042                 }
16043         }
16044         if (ndr_flags & NDR_BUFFERS) {
16045                 int level = ndr_push_get_switch_value(ndr, r);
16046                 switch (level) {
16047                         case 1:
16048                                 if (r->info1) {
16049                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16050                                 }
16051                         break;
16052
16053                         case 2:
16054                                 if (r->info2) {
16055                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16056                                 }
16057                         break;
16058
16059                         default:
16060                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
16061                 }
16062         }
16063         return NDR_ERR_SUCCESS;
16064 }
16065
16066 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
16067 {
16068         int level;
16069         uint32_t _level;
16070         TALLOC_CTX *_mem_save_info1_0;
16071         TALLOC_CTX *_mem_save_info2_0;
16072         level = ndr_pull_get_switch_value(ndr, r);
16073         if (ndr_flags & NDR_SCALARS) {
16074                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
16075                 if (_level != level) {
16076                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
16077                 }
16078                 switch (level) {
16079                         case 1: {
16080                                 uint32_t _ptr_info1;
16081                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
16082                                 if (_ptr_info1) {
16083                                         NDR_PULL_ALLOC(ndr, r->info1);
16084                                 } else {
16085                                         r->info1 = NULL;
16086                                 }
16087                         break; }
16088
16089                         case 2: {
16090                                 uint32_t _ptr_info2;
16091                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
16092                                 if (_ptr_info2) {
16093                                         NDR_PULL_ALLOC(ndr, r->info2);
16094                                 } else {
16095                                         r->info2 = NULL;
16096                                 }
16097                         break; }
16098
16099                         default:
16100                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
16101                 }
16102         }
16103         if (ndr_flags & NDR_BUFFERS) {
16104                 switch (level) {
16105                         case 1:
16106                                 if (r->info1) {
16107                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
16108                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
16109                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16110                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
16111                                 }
16112                         break;
16113
16114                         case 2:
16115                                 if (r->info2) {
16116                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
16117                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
16118                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16119                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
16120                                 }
16121                         break;
16122
16123                         default:
16124                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
16125                 }
16126         }
16127         return NDR_ERR_SUCCESS;
16128 }
16129
16130 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
16131 {
16132         int level;
16133         level = ndr_print_get_switch_value(ndr, r);
16134         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
16135         switch (level) {
16136                 case 1:
16137                         ndr_print_ptr(ndr, "info1", r->info1);
16138                         ndr->depth++;
16139                         if (r->info1) {
16140                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
16141                         }
16142                         ndr->depth--;
16143                 break;
16144
16145                 case 2:
16146                         ndr_print_ptr(ndr, "info2", r->info2);
16147                         ndr->depth++;
16148                         if (r->info2) {
16149                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
16150                         }
16151                         ndr->depth--;
16152                 break;
16153
16154                 default:
16155                         ndr_print_bad_level(ndr, name, level);
16156         }
16157 }
16158
16159 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
16160 {
16161         if (ndr_flags & NDR_SCALARS) {
16162                 NDR_CHECK(ndr_push_align(ndr, 4));
16163                 {
16164                         uint32_t _flags_save_string = ndr->flags;
16165                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16166                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16167                         ndr->flags = _flags_save_string;
16168                 }
16169         }
16170         if (ndr_flags & NDR_BUFFERS) {
16171                 {
16172                         uint32_t _flags_save_string = ndr->flags;
16173                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16174                         if (r->port_name) {
16175                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
16176                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16177                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
16178                         }
16179                         ndr->flags = _flags_save_string;
16180                 }
16181         }
16182         return NDR_ERR_SUCCESS;
16183 }
16184
16185 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
16186 {
16187         uint32_t _ptr_port_name;
16188         TALLOC_CTX *_mem_save_port_name_0;
16189         if (ndr_flags & NDR_SCALARS) {
16190                 NDR_CHECK(ndr_pull_align(ndr, 4));
16191                 {
16192                         uint32_t _flags_save_string = ndr->flags;
16193                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16194                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16195                         if (_ptr_port_name) {
16196                                 NDR_PULL_ALLOC(ndr, r->port_name);
16197                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16198                         } else {
16199                                 r->port_name = NULL;
16200                         }
16201                         ndr->flags = _flags_save_string;
16202                 }
16203         }
16204         if (ndr_flags & NDR_BUFFERS) {
16205                 {
16206                         uint32_t _flags_save_string = ndr->flags;
16207                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16208                         if (r->port_name) {
16209                                 uint32_t _relative_save_offset;
16210                                 _relative_save_offset = ndr->offset;
16211                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16212                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16213                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16214                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16215                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16216                                 ndr->offset = _relative_save_offset;
16217                         }
16218                         ndr->flags = _flags_save_string;
16219                 }
16220         }
16221         return NDR_ERR_SUCCESS;
16222 }
16223
16224 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
16225 {
16226         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
16227         ndr->depth++;
16228         ndr_print_ptr(ndr, "port_name", r->port_name);
16229         ndr->depth++;
16230         if (r->port_name) {
16231                 ndr_print_string(ndr, "port_name", r->port_name);
16232         }
16233         ndr->depth--;
16234         ndr->depth--;
16235 }
16236
16237 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16238 {
16239         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
16240 }
16241
16242 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16243 {
16244         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16245         return NDR_ERR_SUCCESS;
16246 }
16247
16248 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16249 {
16250         uint32_t v;
16251         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16252         *r = v;
16253         return NDR_ERR_SUCCESS;
16254 }
16255
16256 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
16257 {
16258         ndr_print_uint32(ndr, name, r);
16259         ndr->depth++;
16260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
16261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
16262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
16263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
16264         ndr->depth--;
16265 }
16266
16267 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
16268 {
16269         if (ndr_flags & NDR_SCALARS) {
16270                 NDR_CHECK(ndr_push_align(ndr, 4));
16271                 {
16272                         uint32_t _flags_save_string = ndr->flags;
16273                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16274                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16275                         ndr->flags = _flags_save_string;
16276                 }
16277                 {
16278                         uint32_t _flags_save_string = ndr->flags;
16279                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16280                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16281                         ndr->flags = _flags_save_string;
16282                 }
16283                 {
16284                         uint32_t _flags_save_string = ndr->flags;
16285                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16286                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
16287                         ndr->flags = _flags_save_string;
16288                 }
16289                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
16290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
16291         }
16292         if (ndr_flags & NDR_BUFFERS) {
16293                 {
16294                         uint32_t _flags_save_string = ndr->flags;
16295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16296                         if (r->port_name) {
16297                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
16298                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16299                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
16300                         }
16301                         ndr->flags = _flags_save_string;
16302                 }
16303                 {
16304                         uint32_t _flags_save_string = ndr->flags;
16305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16306                         if (r->monitor_name) {
16307                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
16308                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16309                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
16310                         }
16311                         ndr->flags = _flags_save_string;
16312                 }
16313                 {
16314                         uint32_t _flags_save_string = ndr->flags;
16315                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16316                         if (r->description) {
16317                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->description));
16318                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
16319                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->description));
16320                         }
16321                         ndr->flags = _flags_save_string;
16322                 }
16323         }
16324         return NDR_ERR_SUCCESS;
16325 }
16326
16327 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
16328 {
16329         uint32_t _ptr_port_name;
16330         TALLOC_CTX *_mem_save_port_name_0;
16331         uint32_t _ptr_monitor_name;
16332         TALLOC_CTX *_mem_save_monitor_name_0;
16333         uint32_t _ptr_description;
16334         TALLOC_CTX *_mem_save_description_0;
16335         if (ndr_flags & NDR_SCALARS) {
16336                 NDR_CHECK(ndr_pull_align(ndr, 4));
16337                 {
16338                         uint32_t _flags_save_string = ndr->flags;
16339                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16340                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16341                         if (_ptr_port_name) {
16342                                 NDR_PULL_ALLOC(ndr, r->port_name);
16343                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16344                         } else {
16345                                 r->port_name = NULL;
16346                         }
16347                         ndr->flags = _flags_save_string;
16348                 }
16349                 {
16350                         uint32_t _flags_save_string = ndr->flags;
16351                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16352                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16353                         if (_ptr_monitor_name) {
16354                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16355                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16356                         } else {
16357                                 r->monitor_name = NULL;
16358                         }
16359                         ndr->flags = _flags_save_string;
16360                 }
16361                 {
16362                         uint32_t _flags_save_string = ndr->flags;
16363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16364                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
16365                         if (_ptr_description) {
16366                                 NDR_PULL_ALLOC(ndr, r->description);
16367                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
16368                         } else {
16369                                 r->description = NULL;
16370                         }
16371                         ndr->flags = _flags_save_string;
16372                 }
16373                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
16374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
16375         }
16376         if (ndr_flags & NDR_BUFFERS) {
16377                 {
16378                         uint32_t _flags_save_string = ndr->flags;
16379                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16380                         if (r->port_name) {
16381                                 uint32_t _relative_save_offset;
16382                                 _relative_save_offset = ndr->offset;
16383                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16384                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16385                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16386                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16387                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16388                                 ndr->offset = _relative_save_offset;
16389                         }
16390                         ndr->flags = _flags_save_string;
16391                 }
16392                 {
16393                         uint32_t _flags_save_string = ndr->flags;
16394                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16395                         if (r->monitor_name) {
16396                                 uint32_t _relative_save_offset;
16397                                 _relative_save_offset = ndr->offset;
16398                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16399                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16400                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16401                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16402                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16403                                 ndr->offset = _relative_save_offset;
16404                         }
16405                         ndr->flags = _flags_save_string;
16406                 }
16407                 {
16408                         uint32_t _flags_save_string = ndr->flags;
16409                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16410                         if (r->description) {
16411                                 uint32_t _relative_save_offset;
16412                                 _relative_save_offset = ndr->offset;
16413                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
16414                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
16415                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
16416                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
16417                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
16418                                 ndr->offset = _relative_save_offset;
16419                         }
16420                         ndr->flags = _flags_save_string;
16421                 }
16422         }
16423         return NDR_ERR_SUCCESS;
16424 }
16425
16426 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
16427 {
16428         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
16429         ndr->depth++;
16430         ndr_print_ptr(ndr, "port_name", r->port_name);
16431         ndr->depth++;
16432         if (r->port_name) {
16433                 ndr_print_string(ndr, "port_name", r->port_name);
16434         }
16435         ndr->depth--;
16436         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16437         ndr->depth++;
16438         if (r->monitor_name) {
16439                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16440         }
16441         ndr->depth--;
16442         ndr_print_ptr(ndr, "description", r->description);
16443         ndr->depth++;
16444         if (r->description) {
16445                 ndr_print_string(ndr, "description", r->description);
16446         }
16447         ndr->depth--;
16448         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
16449         ndr_print_uint32(ndr, "reserved", r->reserved);
16450         ndr->depth--;
16451 }
16452
16453 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16454 {
16455         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
16456 }
16457
16458 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
16459 {
16460         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16461         return NDR_ERR_SUCCESS;
16462 }
16463
16464 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
16465 {
16466         uint32_t v;
16467         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16468         *r = v;
16469         return NDR_ERR_SUCCESS;
16470 }
16471
16472 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
16473 {
16474         const char *val = NULL;
16475
16476         switch (r) {
16477                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
16478                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
16479                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
16480                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
16481                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
16482                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
16483                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
16484                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
16485                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
16486                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
16487                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
16488                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
16489                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
16490         }
16491         ndr_print_enum(ndr, name, "ENUM", val, r);
16492 }
16493
16494 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
16495 {
16496         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16497         return NDR_ERR_SUCCESS;
16498 }
16499
16500 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
16501 {
16502         uint32_t v;
16503         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16504         *r = v;
16505         return NDR_ERR_SUCCESS;
16506 }
16507
16508 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
16509 {
16510         const char *val = NULL;
16511
16512         switch (r) {
16513                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
16514                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
16515                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
16516         }
16517         ndr_print_enum(ndr, name, "ENUM", val, r);
16518 }
16519
16520 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
16521 {
16522         if (ndr_flags & NDR_SCALARS) {
16523                 NDR_CHECK(ndr_push_align(ndr, 4));
16524                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
16525                 {
16526                         uint32_t _flags_save_string = ndr->flags;
16527                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16528                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
16529                         ndr->flags = _flags_save_string;
16530                 }
16531                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
16532         }
16533         if (ndr_flags & NDR_BUFFERS) {
16534                 {
16535                         uint32_t _flags_save_string = ndr->flags;
16536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16537                         if (r->status_string) {
16538                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->status_string));
16539                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
16540                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->status_string));
16541                         }
16542                         ndr->flags = _flags_save_string;
16543                 }
16544         }
16545         return NDR_ERR_SUCCESS;
16546 }
16547
16548 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
16549 {
16550         uint32_t _ptr_status_string;
16551         TALLOC_CTX *_mem_save_status_string_0;
16552         if (ndr_flags & NDR_SCALARS) {
16553                 NDR_CHECK(ndr_pull_align(ndr, 4));
16554                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
16555                 {
16556                         uint32_t _flags_save_string = ndr->flags;
16557                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16558                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
16559                         if (_ptr_status_string) {
16560                                 NDR_PULL_ALLOC(ndr, r->status_string);
16561                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
16562                         } else {
16563                                 r->status_string = NULL;
16564                         }
16565                         ndr->flags = _flags_save_string;
16566                 }
16567                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
16568         }
16569         if (ndr_flags & NDR_BUFFERS) {
16570                 {
16571                         uint32_t _flags_save_string = ndr->flags;
16572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16573                         if (r->status_string) {
16574                                 uint32_t _relative_save_offset;
16575                                 _relative_save_offset = ndr->offset;
16576                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
16577                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
16578                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
16579                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
16580                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
16581                                 ndr->offset = _relative_save_offset;
16582                         }
16583                         ndr->flags = _flags_save_string;
16584                 }
16585         }
16586         return NDR_ERR_SUCCESS;
16587 }
16588
16589 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
16590 {
16591         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
16592         ndr->depth++;
16593         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
16594         ndr_print_ptr(ndr, "status_string", r->status_string);
16595         ndr->depth++;
16596         if (r->status_string) {
16597                 ndr_print_string(ndr, "status_string", r->status_string);
16598         }
16599         ndr->depth--;
16600         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
16601         ndr->depth--;
16602 }
16603
16604 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
16605 {
16606         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
16607 }
16608
16609 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
16610 {
16611         if (ndr_flags & NDR_SCALARS) {
16612                 NDR_CHECK(ndr_push_align(ndr, 4));
16613                 {
16614                         uint32_t _flags_save_string = ndr->flags;
16615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16616                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16617                         ndr->flags = _flags_save_string;
16618                 }
16619                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
16620         }
16621         if (ndr_flags & NDR_BUFFERS) {
16622                 {
16623                         uint32_t _flags_save_string = ndr->flags;
16624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16625                         if (r->port_name) {
16626                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
16627                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16628                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
16629                         }
16630                         ndr->flags = _flags_save_string;
16631                 }
16632         }
16633         return NDR_ERR_SUCCESS;
16634 }
16635
16636 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
16637 {
16638         uint32_t _ptr_port_name;
16639         TALLOC_CTX *_mem_save_port_name_0;
16640         if (ndr_flags & NDR_SCALARS) {
16641                 NDR_CHECK(ndr_pull_align(ndr, 4));
16642                 {
16643                         uint32_t _flags_save_string = ndr->flags;
16644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16645                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16646                         if (_ptr_port_name) {
16647                                 NDR_PULL_ALLOC(ndr, r->port_name);
16648                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16649                         } else {
16650                                 r->port_name = NULL;
16651                         }
16652                         ndr->flags = _flags_save_string;
16653                 }
16654                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
16655         }
16656         if (ndr_flags & NDR_BUFFERS) {
16657                 {
16658                         uint32_t _flags_save_string = ndr->flags;
16659                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16660                         if (r->port_name) {
16661                                 uint32_t _relative_save_offset;
16662                                 _relative_save_offset = ndr->offset;
16663                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16664                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16665                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16666                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16667                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16668                                 ndr->offset = _relative_save_offset;
16669                         }
16670                         ndr->flags = _flags_save_string;
16671                 }
16672         }
16673         return NDR_ERR_SUCCESS;
16674 }
16675
16676 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
16677 {
16678         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
16679         ndr->depth++;
16680         ndr_print_ptr(ndr, "port_name", r->port_name);
16681         ndr->depth++;
16682         if (r->port_name) {
16683                 ndr_print_string(ndr, "port_name", r->port_name);
16684         }
16685         ndr->depth--;
16686         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
16687         ndr->depth--;
16688 }
16689
16690 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
16691 {
16692         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
16693 }
16694
16695 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
16696 {
16697         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16698         {
16699                 uint32_t _flags_save_UNION = ndr->flags;
16700                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
16701                 if (ndr_flags & NDR_SCALARS) {
16702                         int level = ndr_push_get_switch_value(ndr, r);
16703                         switch (level) {
16704                                 case 1: {
16705                                         NDR_CHECK(ndr_push_align(ndr, 4));
16706                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16707                                         NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16708                                 break; }
16709
16710                                 case 2: {
16711                                         NDR_CHECK(ndr_push_align(ndr, 4));
16712                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16713                                         NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16714                                 break; }
16715
16716                                 case 3: {
16717                                         NDR_CHECK(ndr_push_align(ndr, 4));
16718                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16719                                         NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16720                                 break; }
16721
16722                                 case 0xff: {
16723                                         NDR_CHECK(ndr_push_align(ndr, 4));
16724                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16725                                         NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16726                                 break; }
16727
16728                                 default: {
16729                                 break; }
16730
16731                         }
16732                 }
16733                 if (ndr_flags & NDR_BUFFERS) {
16734                         int level = ndr_push_get_switch_value(ndr, r);
16735                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16736                         switch (level) {
16737                                 case 1:
16738                                         NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16739                                 break;
16740
16741                                 case 2:
16742                                         NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16743                                 break;
16744
16745                                 case 3:
16746                                         NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16747                                 break;
16748
16749                                 case 0xff:
16750                                         NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16751                                 break;
16752
16753                                 default:
16754                                 break;
16755
16756                         }
16757                 }
16758                 ndr->flags = _flags_save_UNION;
16759         }
16760         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16761         return NDR_ERR_SUCCESS;
16762 }
16763
16764 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
16765 {
16766         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16767         int level;
16768         {
16769                 uint32_t _flags_save_UNION = ndr->flags;
16770                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
16771                 level = ndr_pull_get_switch_value(ndr, r);
16772                 if (ndr_flags & NDR_SCALARS) {
16773                         switch (level) {
16774                                 case 1: {
16775                                         NDR_CHECK(ndr_pull_align(ndr, 4));
16776                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16777                                         NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16778                                 break; }
16779
16780                                 case 2: {
16781                                         NDR_CHECK(ndr_pull_align(ndr, 4));
16782                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16783                                         NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16784                                 break; }
16785
16786                                 case 3: {
16787                                         NDR_CHECK(ndr_pull_align(ndr, 4));
16788                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16789                                         NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16790                                 break; }
16791
16792                                 case 0xff: {
16793                                         NDR_CHECK(ndr_pull_align(ndr, 4));
16794                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16795                                         NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16796                                 break; }
16797
16798                                 default: {
16799                                 break; }
16800
16801                         }
16802                 }
16803                 if (ndr_flags & NDR_BUFFERS) {
16804                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16805                         switch (level) {
16806                                 case 1:
16807                                         NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16808                                 break;
16809
16810                                 case 2:
16811                                         NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16812                                 break;
16813
16814                                 case 3:
16815                                         NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16816                                 break;
16817
16818                                 case 0xff:
16819                                         NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16820                                 break;
16821
16822                                 default:
16823                                 break;
16824
16825                         }
16826                 }
16827                 ndr->flags = _flags_save_UNION;
16828         }
16829         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16830         return NDR_ERR_SUCCESS;
16831 }
16832
16833 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
16834 {
16835         int level;
16836         {
16837                 uint32_t _flags_save_UNION = ndr->flags;
16838                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
16839                 level = ndr_print_get_switch_value(ndr, r);
16840                 ndr_print_union(ndr, name, level, "spoolss_PortInfo");
16841                 switch (level) {
16842                         case 1:
16843                                 ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
16844                         break;
16845
16846                         case 2:
16847                                 ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
16848                         break;
16849
16850                         case 3:
16851                                 ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
16852                         break;
16853
16854                         case 0xff:
16855                                 ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
16856                         break;
16857
16858                         default:
16859                         break;
16860
16861                 }
16862                 ndr->flags = _flags_save_UNION;
16863         }
16864 }
16865
16866 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
16867 {
16868         if (ndr_flags & NDR_SCALARS) {
16869                 NDR_CHECK(ndr_push_align(ndr, 4));
16870                 {
16871                         uint32_t _flags_save_string = ndr->flags;
16872                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16873                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16874                         ndr->flags = _flags_save_string;
16875                 }
16876         }
16877         if (ndr_flags & NDR_BUFFERS) {
16878                 {
16879                         uint32_t _flags_save_string = ndr->flags;
16880                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16881                         if (r->monitor_name) {
16882                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
16883                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16884                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
16885                         }
16886                         ndr->flags = _flags_save_string;
16887                 }
16888         }
16889         return NDR_ERR_SUCCESS;
16890 }
16891
16892 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
16893 {
16894         uint32_t _ptr_monitor_name;
16895         TALLOC_CTX *_mem_save_monitor_name_0;
16896         if (ndr_flags & NDR_SCALARS) {
16897                 NDR_CHECK(ndr_pull_align(ndr, 4));
16898                 {
16899                         uint32_t _flags_save_string = ndr->flags;
16900                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16901                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16902                         if (_ptr_monitor_name) {
16903                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16904                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16905                         } else {
16906                                 r->monitor_name = NULL;
16907                         }
16908                         ndr->flags = _flags_save_string;
16909                 }
16910         }
16911         if (ndr_flags & NDR_BUFFERS) {
16912                 {
16913                         uint32_t _flags_save_string = ndr->flags;
16914                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16915                         if (r->monitor_name) {
16916                                 uint32_t _relative_save_offset;
16917                                 _relative_save_offset = ndr->offset;
16918                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16919                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16920                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16921                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16922                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16923                                 ndr->offset = _relative_save_offset;
16924                         }
16925                         ndr->flags = _flags_save_string;
16926                 }
16927         }
16928         return NDR_ERR_SUCCESS;
16929 }
16930
16931 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
16932 {
16933         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
16934         ndr->depth++;
16935         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16936         ndr->depth++;
16937         if (r->monitor_name) {
16938                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16939         }
16940         ndr->depth--;
16941         ndr->depth--;
16942 }
16943
16944 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16945 {
16946         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
16947 }
16948
16949 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
16950 {
16951         if (ndr_flags & NDR_SCALARS) {
16952                 NDR_CHECK(ndr_push_align(ndr, 4));
16953                 {
16954                         uint32_t _flags_save_string = ndr->flags;
16955                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16956                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16957                         ndr->flags = _flags_save_string;
16958                 }
16959                 {
16960                         uint32_t _flags_save_string = ndr->flags;
16961                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16962                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
16963                         ndr->flags = _flags_save_string;
16964                 }
16965                 {
16966                         uint32_t _flags_save_string = ndr->flags;
16967                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16968                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
16969                         ndr->flags = _flags_save_string;
16970                 }
16971         }
16972         if (ndr_flags & NDR_BUFFERS) {
16973                 {
16974                         uint32_t _flags_save_string = ndr->flags;
16975                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16976                         if (r->monitor_name) {
16977                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
16978                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16979                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
16980                         }
16981                         ndr->flags = _flags_save_string;
16982                 }
16983                 {
16984                         uint32_t _flags_save_string = ndr->flags;
16985                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16986                         if (r->environment) {
16987                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->environment));
16988                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
16989                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->environment));
16990                         }
16991                         ndr->flags = _flags_save_string;
16992                 }
16993                 {
16994                         uint32_t _flags_save_string = ndr->flags;
16995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16996                         if (r->dll_name) {
16997                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dll_name));
16998                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
16999                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dll_name));
17000                         }
17001                         ndr->flags = _flags_save_string;
17002                 }
17003         }
17004         return NDR_ERR_SUCCESS;
17005 }
17006
17007 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
17008 {
17009         uint32_t _ptr_monitor_name;
17010         TALLOC_CTX *_mem_save_monitor_name_0;
17011         uint32_t _ptr_environment;
17012         TALLOC_CTX *_mem_save_environment_0;
17013         uint32_t _ptr_dll_name;
17014         TALLOC_CTX *_mem_save_dll_name_0;
17015         if (ndr_flags & NDR_SCALARS) {
17016                 NDR_CHECK(ndr_pull_align(ndr, 4));
17017                 {
17018                         uint32_t _flags_save_string = ndr->flags;
17019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17020                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17021                         if (_ptr_monitor_name) {
17022                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17023                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17024                         } else {
17025                                 r->monitor_name = NULL;
17026                         }
17027                         ndr->flags = _flags_save_string;
17028                 }
17029                 {
17030                         uint32_t _flags_save_string = ndr->flags;
17031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17032                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
17033                         if (_ptr_environment) {
17034                                 NDR_PULL_ALLOC(ndr, r->environment);
17035                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
17036                         } else {
17037                                 r->environment = NULL;
17038                         }
17039                         ndr->flags = _flags_save_string;
17040                 }
17041                 {
17042                         uint32_t _flags_save_string = ndr->flags;
17043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17044                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
17045                         if (_ptr_dll_name) {
17046                                 NDR_PULL_ALLOC(ndr, r->dll_name);
17047                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
17048                         } else {
17049                                 r->dll_name = NULL;
17050                         }
17051                         ndr->flags = _flags_save_string;
17052                 }
17053         }
17054         if (ndr_flags & NDR_BUFFERS) {
17055                 {
17056                         uint32_t _flags_save_string = ndr->flags;
17057                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17058                         if (r->monitor_name) {
17059                                 uint32_t _relative_save_offset;
17060                                 _relative_save_offset = ndr->offset;
17061                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17062                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17063                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17064                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17065                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17066                                 ndr->offset = _relative_save_offset;
17067                         }
17068                         ndr->flags = _flags_save_string;
17069                 }
17070                 {
17071                         uint32_t _flags_save_string = ndr->flags;
17072                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17073                         if (r->environment) {
17074                                 uint32_t _relative_save_offset;
17075                                 _relative_save_offset = ndr->offset;
17076                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
17077                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
17078                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
17079                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
17080                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
17081                                 ndr->offset = _relative_save_offset;
17082                         }
17083                         ndr->flags = _flags_save_string;
17084                 }
17085                 {
17086                         uint32_t _flags_save_string = ndr->flags;
17087                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17088                         if (r->dll_name) {
17089                                 uint32_t _relative_save_offset;
17090                                 _relative_save_offset = ndr->offset;
17091                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
17092                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17093                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
17094                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
17095                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
17096                                 ndr->offset = _relative_save_offset;
17097                         }
17098                         ndr->flags = _flags_save_string;
17099                 }
17100         }
17101         return NDR_ERR_SUCCESS;
17102 }
17103
17104 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
17105 {
17106         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
17107         ndr->depth++;
17108         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17109         ndr->depth++;
17110         if (r->monitor_name) {
17111                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17112         }
17113         ndr->depth--;
17114         ndr_print_ptr(ndr, "environment", r->environment);
17115         ndr->depth++;
17116         if (r->environment) {
17117                 ndr_print_string(ndr, "environment", r->environment);
17118         }
17119         ndr->depth--;
17120         ndr_print_ptr(ndr, "dll_name", r->dll_name);
17121         ndr->depth++;
17122         if (r->dll_name) {
17123                 ndr_print_string(ndr, "dll_name", r->dll_name);
17124         }
17125         ndr->depth--;
17126         ndr->depth--;
17127 }
17128
17129 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17130 {
17131         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
17132 }
17133
17134 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
17135 {
17136         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17137         {
17138                 uint32_t _flags_save_UNION = ndr->flags;
17139                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17140                 if (ndr_flags & NDR_SCALARS) {
17141                         int level = ndr_push_get_switch_value(ndr, r);
17142                         switch (level) {
17143                                 case 1: {
17144                                         NDR_CHECK(ndr_push_align(ndr, 4));
17145                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17146                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17147                                 break; }
17148
17149                                 case 2: {
17150                                         NDR_CHECK(ndr_push_align(ndr, 4));
17151                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17152                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17153                                 break; }
17154
17155                                 default: {
17156                                 break; }
17157
17158                         }
17159                 }
17160                 if (ndr_flags & NDR_BUFFERS) {
17161                         int level = ndr_push_get_switch_value(ndr, r);
17162                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17163                         switch (level) {
17164                                 case 1:
17165                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
17166                                 break;
17167
17168                                 case 2:
17169                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
17170                                 break;
17171
17172                                 default:
17173                                 break;
17174
17175                         }
17176                 }
17177                 ndr->flags = _flags_save_UNION;
17178         }
17179         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17180         return NDR_ERR_SUCCESS;
17181 }
17182
17183 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
17184 {
17185         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17186         int level;
17187         {
17188                 uint32_t _flags_save_UNION = ndr->flags;
17189                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17190                 level = ndr_pull_get_switch_value(ndr, r);
17191                 if (ndr_flags & NDR_SCALARS) {
17192                         switch (level) {
17193                                 case 1: {
17194                                         NDR_CHECK(ndr_pull_align(ndr, 4));
17195                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17196                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17197                                 break; }
17198
17199                                 case 2: {
17200                                         NDR_CHECK(ndr_pull_align(ndr, 4));
17201                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17202                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17203                                 break; }
17204
17205                                 default: {
17206                                 break; }
17207
17208                         }
17209                 }
17210                 if (ndr_flags & NDR_BUFFERS) {
17211                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17212                         switch (level) {
17213                                 case 1:
17214                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
17215                                 break;
17216
17217                                 case 2:
17218                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
17219                                 break;
17220
17221                                 default:
17222                                 break;
17223
17224                         }
17225                 }
17226                 ndr->flags = _flags_save_UNION;
17227         }
17228         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17229         return NDR_ERR_SUCCESS;
17230 }
17231
17232 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
17233 {
17234         int level;
17235         {
17236                 uint32_t _flags_save_UNION = ndr->flags;
17237                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17238                 level = ndr_print_get_switch_value(ndr, r);
17239                 ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
17240                 switch (level) {
17241                         case 1:
17242                                 ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
17243                         break;
17244
17245                         case 2:
17246                                 ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
17247                         break;
17248
17249                         default:
17250                         break;
17251
17252                 }
17253                 ndr->flags = _flags_save_UNION;
17254         }
17255 }
17256
17257 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
17258 {
17259         if (ndr_flags & NDR_SCALARS) {
17260                 NDR_CHECK(ndr_push_align(ndr, 4));
17261                 {
17262                         uint32_t _flags_save_string = ndr->flags;
17263                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17264                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
17265                         ndr->flags = _flags_save_string;
17266                 }
17267         }
17268         if (ndr_flags & NDR_BUFFERS) {
17269                 {
17270                         uint32_t _flags_save_string = ndr->flags;
17271                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17272                         if (r->name_array) {
17273                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->name_array));
17274                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
17275                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->name_array));
17276                         }
17277                         ndr->flags = _flags_save_string;
17278                 }
17279         }
17280         return NDR_ERR_SUCCESS;
17281 }
17282
17283 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
17284 {
17285         uint32_t _ptr_name_array;
17286         TALLOC_CTX *_mem_save_name_array_0;
17287         if (ndr_flags & NDR_SCALARS) {
17288                 NDR_CHECK(ndr_pull_align(ndr, 4));
17289                 {
17290                         uint32_t _flags_save_string = ndr->flags;
17291                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17292                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
17293                         if (_ptr_name_array) {
17294                                 NDR_PULL_ALLOC(ndr, r->name_array);
17295                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
17296                         } else {
17297                                 r->name_array = NULL;
17298                         }
17299                         ndr->flags = _flags_save_string;
17300                 }
17301         }
17302         if (ndr_flags & NDR_BUFFERS) {
17303                 {
17304                         uint32_t _flags_save_string = ndr->flags;
17305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17306                         if (r->name_array) {
17307                                 uint32_t _relative_save_offset;
17308                                 _relative_save_offset = ndr->offset;
17309                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
17310                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
17311                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
17312                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
17313                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
17314                                 ndr->offset = _relative_save_offset;
17315                         }
17316                         ndr->flags = _flags_save_string;
17317                 }
17318         }
17319         return NDR_ERR_SUCCESS;
17320 }
17321
17322 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
17323 {
17324         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
17325         ndr->depth++;
17326         ndr_print_ptr(ndr, "name_array", r->name_array);
17327         ndr->depth++;
17328         if (r->name_array) {
17329                 ndr_print_string(ndr, "name_array", r->name_array);
17330         }
17331         ndr->depth--;
17332         ndr->depth--;
17333 }
17334
17335 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17336 {
17337         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
17338 }
17339
17340 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
17341 {
17342         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17343         {
17344                 uint32_t _flags_save_UNION = ndr->flags;
17345                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17346                 if (ndr_flags & NDR_SCALARS) {
17347                         int level = ndr_push_get_switch_value(ndr, r);
17348                         switch (level) {
17349                                 case 1: {
17350                                         NDR_CHECK(ndr_push_align(ndr, 4));
17351                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17352                                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
17353                                 break; }
17354
17355                                 default: {
17356                                 break; }
17357
17358                         }
17359                 }
17360                 if (ndr_flags & NDR_BUFFERS) {
17361                         int level = ndr_push_get_switch_value(ndr, r);
17362                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17363                         switch (level) {
17364                                 case 1:
17365                                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
17366                                 break;
17367
17368                                 default:
17369                                 break;
17370
17371                         }
17372                 }
17373                 ndr->flags = _flags_save_UNION;
17374         }
17375         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17376         return NDR_ERR_SUCCESS;
17377 }
17378
17379 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
17380 {
17381         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17382         int level;
17383         {
17384                 uint32_t _flags_save_UNION = ndr->flags;
17385                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17386                 level = ndr_pull_get_switch_value(ndr, r);
17387                 if (ndr_flags & NDR_SCALARS) {
17388                         switch (level) {
17389                                 case 1: {
17390                                         NDR_CHECK(ndr_pull_align(ndr, 4));
17391                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17392                                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
17393                                 break; }
17394
17395                                 default: {
17396                                 break; }
17397
17398                         }
17399                 }
17400                 if (ndr_flags & NDR_BUFFERS) {
17401                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17402                         switch (level) {
17403                                 case 1:
17404                                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
17405                                 break;
17406
17407                                 default:
17408                                 break;
17409
17410                         }
17411                 }
17412                 ndr->flags = _flags_save_UNION;
17413         }
17414         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17415         return NDR_ERR_SUCCESS;
17416 }
17417
17418 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
17419 {
17420         int level;
17421         {
17422                 uint32_t _flags_save_UNION = ndr->flags;
17423                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17424                 level = ndr_print_get_switch_value(ndr, r);
17425                 ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
17426                 switch (level) {
17427                         case 1:
17428                                 ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
17429                         break;
17430
17431                         default:
17432                         break;
17433
17434                 }
17435                 ndr->flags = _flags_save_UNION;
17436         }
17437 }
17438
17439 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17440 {
17441         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17442         return NDR_ERR_SUCCESS;
17443 }
17444
17445 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17446 {
17447         uint32_t v;
17448         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17449         *r = v;
17450         return NDR_ERR_SUCCESS;
17451 }
17452
17453 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17454 {
17455         ndr_print_uint32(ndr, name, r);
17456         ndr->depth++;
17457         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
17458         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
17459         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
17460         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
17461         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
17462         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
17463         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
17464         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
17465         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
17466         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
17467         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
17468         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
17469         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
17470         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
17471         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
17472         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
17473         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
17474         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
17475         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
17476         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
17477         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
17478         ndr->depth--;
17479 }
17480
17481 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobNotifyField r)
17482 {
17483         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
17484         return NDR_ERR_SUCCESS;
17485 }
17486
17487 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobNotifyField *r)
17488 {
17489         uint16_t v;
17490         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
17491         *r = v;
17492         return NDR_ERR_SUCCESS;
17493 }
17494
17495 _PUBLIC_ void ndr_print_spoolss_JobNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_JobNotifyField r)
17496 {
17497         const char *val = NULL;
17498
17499         switch (r) {
17500                 case JOB_NOTIFY_FIELD_PRINTER_NAME: val = "JOB_NOTIFY_FIELD_PRINTER_NAME"; break;
17501                 case JOB_NOTIFY_FIELD_MACHINE_NAME: val = "JOB_NOTIFY_FIELD_MACHINE_NAME"; break;
17502                 case JOB_NOTIFY_FIELD_PORT_NAME: val = "JOB_NOTIFY_FIELD_PORT_NAME"; break;
17503                 case JOB_NOTIFY_FIELD_USER_NAME: val = "JOB_NOTIFY_FIELD_USER_NAME"; break;
17504                 case JOB_NOTIFY_FIELD_NOTIFY_NAME: val = "JOB_NOTIFY_FIELD_NOTIFY_NAME"; break;
17505                 case JOB_NOTIFY_FIELD_DATATYPE: val = "JOB_NOTIFY_FIELD_DATATYPE"; break;
17506                 case JOB_NOTIFY_FIELD_PRINT_PROCESSOR: val = "JOB_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
17507                 case JOB_NOTIFY_FIELD_PARAMETERS: val = "JOB_NOTIFY_FIELD_PARAMETERS"; break;
17508                 case JOB_NOTIFY_FIELD_DRIVER_NAME: val = "JOB_NOTIFY_FIELD_DRIVER_NAME"; break;
17509                 case JOB_NOTIFY_FIELD_DEVMODE: val = "JOB_NOTIFY_FIELD_DEVMODE"; break;
17510                 case JOB_NOTIFY_FIELD_STATUS: val = "JOB_NOTIFY_FIELD_STATUS"; break;
17511                 case JOB_NOTIFY_FIELD_STATUS_STRING: val = "JOB_NOTIFY_FIELD_STATUS_STRING"; break;
17512                 case JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
17513                 case JOB_NOTIFY_FIELD_DOCUMENT: val = "JOB_NOTIFY_FIELD_DOCUMENT"; break;
17514                 case JOB_NOTIFY_FIELD_PRIORITY: val = "JOB_NOTIFY_FIELD_PRIORITY"; break;
17515                 case JOB_NOTIFY_FIELD_POSITION: val = "JOB_NOTIFY_FIELD_POSITION"; break;
17516                 case JOB_NOTIFY_FIELD_SUBMITTED: val = "JOB_NOTIFY_FIELD_SUBMITTED"; break;
17517                 case JOB_NOTIFY_FIELD_START_TIME: val = "JOB_NOTIFY_FIELD_START_TIME"; break;
17518                 case JOB_NOTIFY_FIELD_UNTIL_TIME: val = "JOB_NOTIFY_FIELD_UNTIL_TIME"; break;
17519                 case JOB_NOTIFY_FIELD_TIME: val = "JOB_NOTIFY_FIELD_TIME"; break;
17520                 case JOB_NOTIFY_FIELD_TOTAL_PAGES: val = "JOB_NOTIFY_FIELD_TOTAL_PAGES"; break;
17521                 case JOB_NOTIFY_FIELD_PAGES_PRINTED: val = "JOB_NOTIFY_FIELD_PAGES_PRINTED"; break;
17522                 case JOB_NOTIFY_FIELD_TOTAL_BYTES: val = "JOB_NOTIFY_FIELD_TOTAL_BYTES"; break;
17523                 case JOB_NOTIFY_FIELD_BYTES_PRINTED: val = "JOB_NOTIFY_FIELD_BYTES_PRINTED"; break;
17524         }
17525         ndr_print_enum(ndr, name, "ENUM", val, r);
17526 }
17527
17528 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrintNotifyField r)
17529 {
17530         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
17531         return NDR_ERR_SUCCESS;
17532 }
17533
17534 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrintNotifyField *r)
17535 {
17536         uint16_t v;
17537         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
17538         *r = v;
17539         return NDR_ERR_SUCCESS;
17540 }
17541
17542 _PUBLIC_ void ndr_print_spoolss_PrintNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_PrintNotifyField r)
17543 {
17544         const char *val = NULL;
17545
17546         switch (r) {
17547                 case PRINTER_NOTIFY_FIELD_SERVER_NAME: val = "PRINTER_NOTIFY_FIELD_SERVER_NAME"; break;
17548                 case PRINTER_NOTIFY_FIELD_PRINTER_NAME: val = "PRINTER_NOTIFY_FIELD_PRINTER_NAME"; break;
17549                 case PRINTER_NOTIFY_FIELD_SHARE_NAME: val = "PRINTER_NOTIFY_FIELD_SHARE_NAME"; break;
17550                 case PRINTER_NOTIFY_FIELD_PORT_NAME: val = "PRINTER_NOTIFY_FIELD_PORT_NAME"; break;
17551                 case PRINTER_NOTIFY_FIELD_DRIVER_NAME: val = "PRINTER_NOTIFY_FIELD_DRIVER_NAME"; break;
17552                 case PRINTER_NOTIFY_FIELD_COMMENT: val = "PRINTER_NOTIFY_FIELD_COMMENT"; break;
17553                 case PRINTER_NOTIFY_FIELD_LOCATION: val = "PRINTER_NOTIFY_FIELD_LOCATION"; break;
17554                 case PRINTER_NOTIFY_FIELD_DEVMODE: val = "PRINTER_NOTIFY_FIELD_DEVMODE"; break;
17555                 case PRINTER_NOTIFY_FIELD_SEPFILE: val = "PRINTER_NOTIFY_FIELD_SEPFILE"; break;
17556                 case PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: val = "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
17557                 case PRINTER_NOTIFY_FIELD_PARAMETERS: val = "PRINTER_NOTIFY_FIELD_PARAMETERS"; break;
17558                 case PRINTER_NOTIFY_FIELD_DATATYPE: val = "PRINTER_NOTIFY_FIELD_DATATYPE"; break;
17559                 case PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
17560                 case PRINTER_NOTIFY_FIELD_ATTRIBUTES: val = "PRINTER_NOTIFY_FIELD_ATTRIBUTES"; break;
17561                 case PRINTER_NOTIFY_FIELD_PRIORITY: val = "PRINTER_NOTIFY_FIELD_PRIORITY"; break;
17562                 case PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: val = "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY"; break;
17563                 case PRINTER_NOTIFY_FIELD_START_TIME: val = "PRINTER_NOTIFY_FIELD_START_TIME"; break;
17564                 case PRINTER_NOTIFY_FIELD_UNTIL_TIME: val = "PRINTER_NOTIFY_FIELD_UNTIL_TIME"; break;
17565                 case PRINTER_NOTIFY_FIELD_STATUS: val = "PRINTER_NOTIFY_FIELD_STATUS"; break;
17566                 case PRINTER_NOTIFY_FIELD_STATUS_STRING: val = "PRINTER_NOTIFY_FIELD_STATUS_STRING"; break;
17567                 case PRINTER_NOTIFY_FIELD_CJOBS: val = "PRINTER_NOTIFY_FIELD_CJOBS"; break;
17568                 case PRINTER_NOTIFY_FIELD_AVERAGE_PPM: val = "PRINTER_NOTIFY_FIELD_AVERAGE_PPM"; break;
17569                 case PRINTER_NOTIFY_FIELD_TOTAL_PAGES: val = "PRINTER_NOTIFY_FIELD_TOTAL_PAGES"; break;
17570                 case PRINTER_NOTIFY_FIELD_PAGES_PRINTED: val = "PRINTER_NOTIFY_FIELD_PAGES_PRINTED"; break;
17571                 case PRINTER_NOTIFY_FIELD_TOTAL_BYTES: val = "PRINTER_NOTIFY_FIELD_TOTAL_BYTES"; break;
17572                 case PRINTER_NOTIFY_FIELD_BYTES_PRINTED: val = "PRINTER_NOTIFY_FIELD_BYTES_PRINTED"; break;
17573                 case PRINTER_NOTIFY_FIELD_OBJECT_GUID: val = "PRINTER_NOTIFY_FIELD_OBJECT_GUID"; break;
17574                 case PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: val = "PRINTER_NOTIFY_FIELD_FRIENDLY_NAME"; break;
17575         }
17576         ndr_print_enum(ndr, name, "ENUM", val, r);
17577 }
17578
17579 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
17580 {
17581         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
17582         return NDR_ERR_SUCCESS;
17583 }
17584
17585 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
17586 {
17587         uint16_t v;
17588         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
17589         *r = v;
17590         return NDR_ERR_SUCCESS;
17591 }
17592
17593 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
17594 {
17595         const char *val = NULL;
17596
17597         switch (r) {
17598                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
17599                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
17600         }
17601         ndr_print_enum(ndr, name, "ENUM", val, r);
17602 }
17603
17604 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, const union spoolss_Field *r)
17605 {
17606         if (ndr_flags & NDR_SCALARS) {
17607                 int level = ndr_push_get_switch_value(ndr, r);
17608                 switch (level) {
17609                         case PRINTER_NOTIFY_TYPE: {
17610                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17611                         break; }
17612
17613                         case JOB_NOTIFY_TYPE: {
17614                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17615                         break; }
17616
17617                         default: {
17618                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17619                         break; }
17620
17621                 }
17622         }
17623         if (ndr_flags & NDR_BUFFERS) {
17624                 int level = ndr_push_get_switch_value(ndr, r);
17625                 switch (level) {
17626                         case PRINTER_NOTIFY_TYPE:
17627                         break;
17628
17629                         case JOB_NOTIFY_TYPE:
17630                         break;
17631
17632                         default:
17633                         break;
17634
17635                 }
17636         }
17637         return NDR_ERR_SUCCESS;
17638 }
17639
17640 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, union spoolss_Field *r)
17641 {
17642         int level;
17643         level = ndr_pull_get_switch_value(ndr, r);
17644         if (ndr_flags & NDR_SCALARS) {
17645                 switch (level) {
17646                         case PRINTER_NOTIFY_TYPE: {
17647                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17648                         break; }
17649
17650                         case JOB_NOTIFY_TYPE: {
17651                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17652                         break; }
17653
17654                         default: {
17655                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17656                         break; }
17657
17658                 }
17659         }
17660         if (ndr_flags & NDR_BUFFERS) {
17661                 switch (level) {
17662                         case PRINTER_NOTIFY_TYPE:
17663                         break;
17664
17665                         case JOB_NOTIFY_TYPE:
17666                         break;
17667
17668                         default:
17669                         break;
17670
17671                 }
17672         }
17673         return NDR_ERR_SUCCESS;
17674 }
17675
17676 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
17677 {
17678         uint32_t cntr_fields_1;
17679         if (ndr_flags & NDR_SCALARS) {
17680                 NDR_CHECK(ndr_push_align(ndr, 4));
17681                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17682                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
17683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
17684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
17685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17686                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
17687         }
17688         if (ndr_flags & NDR_BUFFERS) {
17689                 if (r->fields) {
17690                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17691                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17692                                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
17693                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17694                         }
17695                 }
17696         }
17697         return NDR_ERR_SUCCESS;
17698 }
17699
17700 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
17701 {
17702         uint32_t _ptr_fields;
17703         uint32_t cntr_fields_1;
17704         TALLOC_CTX *_mem_save_fields_0;
17705         TALLOC_CTX *_mem_save_fields_1;
17706         if (ndr_flags & NDR_SCALARS) {
17707                 NDR_CHECK(ndr_pull_align(ndr, 4));
17708                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17709                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
17710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
17711                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
17712                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17713                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
17714                 if (_ptr_fields) {
17715                         NDR_PULL_ALLOC(ndr, r->fields);
17716                 } else {
17717                         r->fields = NULL;
17718                 }
17719         }
17720         if (ndr_flags & NDR_BUFFERS) {
17721                 if (r->fields) {
17722                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
17723                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17724                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
17725                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
17726                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
17727                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17728                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17729                                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
17730                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17731                         }
17732                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
17733                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
17734                 }
17735                 if (r->fields) {
17736                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
17737                 }
17738         }
17739         return NDR_ERR_SUCCESS;
17740 }
17741
17742 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
17743 {
17744         uint32_t cntr_fields_1;
17745         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
17746         ndr->depth++;
17747         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17748         ndr_print_uint16(ndr, "u1", r->u1);
17749         ndr_print_uint32(ndr, "u2", r->u2);
17750         ndr_print_uint32(ndr, "u3", r->u3);
17751         ndr_print_uint32(ndr, "count", r->count);
17752         ndr_print_ptr(ndr, "fields", r->fields);
17753         ndr->depth++;
17754         if (r->fields) {
17755                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
17756                 ndr->depth++;
17757                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
17758                         char *idx_1=NULL;
17759                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
17760                                 ndr_print_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type);
17761                                 ndr_print_spoolss_Field(ndr, "fields", &r->fields[cntr_fields_1]);
17762                                 free(idx_1);
17763                         }
17764                 }
17765                 ndr->depth--;
17766         }
17767         ndr->depth--;
17768         ndr->depth--;
17769 }
17770
17771 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17772 {
17773         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17774         return NDR_ERR_SUCCESS;
17775 }
17776
17777 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17778 {
17779         uint32_t v;
17780         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17781         *r = v;
17782         return NDR_ERR_SUCCESS;
17783 }
17784
17785 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17786 {
17787         ndr_print_uint32(ndr, name, r);
17788         ndr->depth++;
17789         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
17790         ndr->depth--;
17791 }
17792
17793 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
17794 {
17795         uint32_t cntr_types_1;
17796         if (ndr_flags & NDR_SCALARS) {
17797                 NDR_CHECK(ndr_push_align(ndr, 4));
17798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17799                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
17800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17801                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
17802         }
17803         if (ndr_flags & NDR_BUFFERS) {
17804                 if (r->types) {
17805                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17806                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17807                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17808                         }
17809                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17810                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17811                         }
17812                 }
17813         }
17814         return NDR_ERR_SUCCESS;
17815 }
17816
17817 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
17818 {
17819         uint32_t _ptr_types;
17820         uint32_t cntr_types_1;
17821         TALLOC_CTX *_mem_save_types_0;
17822         TALLOC_CTX *_mem_save_types_1;
17823         if (ndr_flags & NDR_SCALARS) {
17824                 NDR_CHECK(ndr_pull_align(ndr, 4));
17825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17826                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
17827                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17828                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
17829                 if (_ptr_types) {
17830                         NDR_PULL_ALLOC(ndr, r->types);
17831                 } else {
17832                         r->types = NULL;
17833                 }
17834         }
17835         if (ndr_flags & NDR_BUFFERS) {
17836                 if (r->types) {
17837                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
17838                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17839                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
17840                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
17841                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
17842                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17843                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17844                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17845                         }
17846                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17847                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17848                         }
17849                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
17850                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
17851                 }
17852                 if (r->types) {
17853                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
17854                 }
17855         }
17856         return NDR_ERR_SUCCESS;
17857 }
17858
17859 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
17860 {
17861         uint32_t cntr_types_1;
17862         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
17863         ndr->depth++;
17864         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17865         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
17866         ndr_print_uint32(ndr, "count", r->count);
17867         ndr_print_ptr(ndr, "types", r->types);
17868         ndr->depth++;
17869         if (r->types) {
17870                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
17871                 ndr->depth++;
17872                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
17873                         char *idx_1=NULL;
17874                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
17875                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
17876                                 free(idx_1);
17877                         }
17878                 }
17879                 ndr->depth--;
17880         }
17881         ndr->depth--;
17882         ndr->depth--;
17883 }
17884
17885 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
17886 {
17887         if (ndr_flags & NDR_SCALARS) {
17888                 NDR_CHECK(ndr_push_align(ndr, 4));
17889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17890                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
17891         }
17892         if (ndr_flags & NDR_BUFFERS) {
17893                 if (r->string) {
17894                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
17895                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
17896                 }
17897         }
17898         return NDR_ERR_SUCCESS;
17899 }
17900
17901 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
17902 {
17903         uint32_t _ptr_string;
17904         TALLOC_CTX *_mem_save_string_0;
17905         if (ndr_flags & NDR_SCALARS) {
17906                 NDR_CHECK(ndr_pull_align(ndr, 4));
17907                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17908                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
17909                 if (_ptr_string) {
17910                         NDR_PULL_ALLOC(ndr, r->string);
17911                 } else {
17912                         r->string = NULL;
17913                 }
17914         }
17915         if (ndr_flags & NDR_BUFFERS) {
17916                 if (r->string) {
17917                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17918                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
17919                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
17920                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
17921                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
17922                 }
17923                 if (r->string) {
17924                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
17925                 }
17926         }
17927         return NDR_ERR_SUCCESS;
17928 }
17929
17930 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
17931 {
17932         ndr_print_struct(ndr, name, "spoolss_NotifyString");
17933         ndr->depth++;
17934         ndr_print_uint32(ndr, "size", r->size);
17935         ndr_print_ptr(ndr, "string", r->string);
17936         ndr->depth++;
17937         if (r->string) {
17938                 ndr_print_string(ndr, "string", r->string);
17939         }
17940         ndr->depth--;
17941         ndr->depth--;
17942 }
17943
17944 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
17945 {
17946         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17947         return NDR_ERR_SUCCESS;
17948 }
17949
17950 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
17951 {
17952         uint32_t v;
17953         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17954         *r = v;
17955         return NDR_ERR_SUCCESS;
17956 }
17957
17958 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
17959 {
17960         const char *val = NULL;
17961
17962         switch (r) {
17963                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
17964                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
17965                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
17966                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
17967                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
17968         }
17969         ndr_print_enum(ndr, name, "ENUM", val, r);
17970 }
17971
17972 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
17973 {
17974         if (ndr_flags & NDR_SCALARS) {
17975                 int level = ndr_push_get_switch_value(ndr, r);
17976                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17977                 switch (level) {
17978                         case 1: {
17979                                 uint32_t cntr_integer_0;
17980                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17981                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
17982                                 }
17983                         break; }
17984
17985                         case 2: {
17986                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17987                         break; }
17988
17989                         case 3: {
17990                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17991                         break; }
17992
17993                         case 4: {
17994                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17995                         break; }
17996
17997                         case 5: {
17998                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17999                         break; }
18000
18001                         default:
18002                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18003                 }
18004         }
18005         if (ndr_flags & NDR_BUFFERS) {
18006                 int level = ndr_push_get_switch_value(ndr, r);
18007                 switch (level) {
18008                         case 1:
18009                         break;
18010
18011                         case 2:
18012                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18013                         break;
18014
18015                         case 3:
18016                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18017                         break;
18018
18019                         case 4:
18020                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18021                         break;
18022
18023                         case 5:
18024                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18025                         break;
18026
18027                         default:
18028                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18029                 }
18030         }
18031         return NDR_ERR_SUCCESS;
18032 }
18033
18034 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
18035 {
18036         int level;
18037         uint32_t _level;
18038         level = ndr_pull_get_switch_value(ndr, r);
18039         if (ndr_flags & NDR_SCALARS) {
18040                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18041                 if (_level != level) {
18042                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
18043                 }
18044                 switch (level) {
18045                         case 1: {
18046                                 uint32_t cntr_integer_0;
18047                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18048                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
18049                                 }
18050                         break; }
18051
18052                         case 2: {
18053                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18054                         break; }
18055
18056                         case 3: {
18057                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18058                         break; }
18059
18060                         case 4: {
18061                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18062                         break; }
18063
18064                         case 5: {
18065                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18066                         break; }
18067
18068                         default:
18069                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18070                 }
18071         }
18072         if (ndr_flags & NDR_BUFFERS) {
18073                 switch (level) {
18074                         case 1:
18075                         break;
18076
18077                         case 2:
18078                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18079                         break;
18080
18081                         case 3:
18082                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18083                         break;
18084
18085                         case 4:
18086                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18087                         break;
18088
18089                         case 5:
18090                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18091                         break;
18092
18093                         default:
18094                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18095                 }
18096         }
18097         return NDR_ERR_SUCCESS;
18098 }
18099
18100 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
18101 {
18102         int level;
18103         uint32_t cntr_integer_0;
18104         level = ndr_print_get_switch_value(ndr, r);
18105         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
18106         switch (level) {
18107                 case 1:
18108                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
18109                         ndr->depth++;
18110                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
18111                                 char *idx_0=NULL;
18112                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
18113                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
18114                                         free(idx_0);
18115                                 }
18116                         }
18117                         ndr->depth--;
18118                 break;
18119
18120                 case 2:
18121                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
18122                 break;
18123
18124                 case 3:
18125                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
18126                 break;
18127
18128                 case 4:
18129                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
18130                 break;
18131
18132                 case 5:
18133                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
18134                 break;
18135
18136                 default:
18137                         ndr_print_bad_level(ndr, name, level);
18138         }
18139 }
18140
18141 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
18142 {
18143         if (ndr_flags & NDR_SCALARS) {
18144                 NDR_CHECK(ndr_push_align(ndr, 4));
18145                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18146                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->field, r->type));
18147                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18148                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
18149                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
18150                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
18151                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18152         }
18153         if (ndr_flags & NDR_BUFFERS) {
18154                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18155         }
18156         return NDR_ERR_SUCCESS;
18157 }
18158
18159 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
18160 {
18161         if (ndr_flags & NDR_SCALARS) {
18162                 NDR_CHECK(ndr_pull_align(ndr, 4));
18163                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18164                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->field, r->type));
18165                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18166                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
18167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
18168                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
18169                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18170         }
18171         if (ndr_flags & NDR_BUFFERS) {
18172                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18173         }
18174         return NDR_ERR_SUCCESS;
18175 }
18176
18177 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
18178 {
18179         ndr_print_struct(ndr, name, "spoolss_Notify");
18180         ndr->depth++;
18181         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
18182         ndr_print_set_switch_value(ndr, &r->field, r->type);
18183         ndr_print_spoolss_Field(ndr, "field", &r->field);
18184         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
18185         ndr_print_uint32(ndr, "job_id", r->job_id);
18186         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
18187         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
18188         ndr->depth--;
18189 }
18190
18191 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
18192 {
18193         uint32_t cntr_notifies_0;
18194         if (ndr_flags & NDR_SCALARS) {
18195                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18196                 NDR_CHECK(ndr_push_align(ndr, 4));
18197                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
18198                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
18199                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18200                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18201                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
18202                 }
18203         }
18204         if (ndr_flags & NDR_BUFFERS) {
18205                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18206                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
18207                 }
18208         }
18209         return NDR_ERR_SUCCESS;
18210 }
18211
18212 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
18213 {
18214         uint32_t cntr_notifies_0;
18215         TALLOC_CTX *_mem_save_notifies_0;
18216         if (ndr_flags & NDR_SCALARS) {
18217                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
18218                 NDR_CHECK(ndr_pull_align(ndr, 4));
18219                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
18221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18222                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
18223                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
18224                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
18225                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18226                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
18227                 }
18228                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
18229                 if (r->notifies) {
18230                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
18231                 }
18232         }
18233         if (ndr_flags & NDR_BUFFERS) {
18234                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
18235                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
18236                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18237                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
18238                 }
18239                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
18240         }
18241         return NDR_ERR_SUCCESS;
18242 }
18243
18244 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
18245 {
18246         uint32_t cntr_notifies_0;
18247         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
18248         ndr->depth++;
18249         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
18250         ndr_print_uint32(ndr, "flags", r->flags);
18251         ndr_print_uint32(ndr, "count", r->count);
18252         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
18253         ndr->depth++;
18254         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
18255                 char *idx_0=NULL;
18256                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
18257                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
18258                         free(idx_0);
18259                 }
18260         }
18261         ndr->depth--;
18262         ndr->depth--;
18263 }
18264
18265 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
18266 {
18267         if (ndr_flags & NDR_SCALARS) {
18268                 int level = ndr_push_get_switch_value(ndr, r);
18269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18270                 switch (level) {
18271                         case 0: {
18272                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
18273                         break; }
18274
18275                         default:
18276                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18277                 }
18278         }
18279         if (ndr_flags & NDR_BUFFERS) {
18280                 int level = ndr_push_get_switch_value(ndr, r);
18281                 switch (level) {
18282                         case 0:
18283                                 if (r->info0) {
18284                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
18285                                 }
18286                         break;
18287
18288                         default:
18289                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18290                 }
18291         }
18292         return NDR_ERR_SUCCESS;
18293 }
18294
18295 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
18296 {
18297         int level;
18298         uint32_t _level;
18299         TALLOC_CTX *_mem_save_info0_0;
18300         level = ndr_pull_get_switch_value(ndr, r);
18301         if (ndr_flags & NDR_SCALARS) {
18302                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18303                 if (_level != level) {
18304                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
18305                 }
18306                 switch (level) {
18307                         case 0: {
18308                                 uint32_t _ptr_info0;
18309                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
18310                                 if (_ptr_info0) {
18311                                         NDR_PULL_ALLOC(ndr, r->info0);
18312                                 } else {
18313                                         r->info0 = NULL;
18314                                 }
18315                         break; }
18316
18317                         default:
18318                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18319                 }
18320         }
18321         if (ndr_flags & NDR_BUFFERS) {
18322                 switch (level) {
18323                         case 0:
18324                                 if (r->info0) {
18325                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
18326                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
18327                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
18328                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
18329                                 }
18330                         break;
18331
18332                         default:
18333                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18334                 }
18335         }
18336         return NDR_ERR_SUCCESS;
18337 }
18338
18339 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
18340 {
18341         int level;
18342         level = ndr_print_get_switch_value(ndr, r);
18343         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
18344         switch (level) {
18345                 case 0:
18346                         ndr_print_ptr(ndr, "info0", r->info0);
18347                         ndr->depth++;
18348                         if (r->info0) {
18349                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
18350                         }
18351                         ndr->depth--;
18352                 break;
18353
18354                 default:
18355                         ndr_print_bad_level(ndr, name, level);
18356         }
18357 }
18358
18359 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18360 {
18361         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18362         return NDR_ERR_SUCCESS;
18363 }
18364
18365 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18366 {
18367         uint32_t v;
18368         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18369         *r = v;
18370         return NDR_ERR_SUCCESS;
18371 }
18372
18373 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18374 {
18375         ndr_print_uint32(ndr, name, r);
18376         ndr->depth++;
18377         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
18378         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
18379         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
18380         ndr->depth--;
18381 }
18382
18383 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
18384 {
18385         if (ndr_flags & NDR_SCALARS) {
18386                 NDR_CHECK(ndr_push_align(ndr, 4));
18387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18388                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
18389                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
18390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
18391                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
18392                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
18393                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
18394         }
18395         if (ndr_flags & NDR_BUFFERS) {
18396                 if (r->client) {
18397                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18398                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18399                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18400                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18401                 }
18402                 if (r->user) {
18403                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18404                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18405                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18406                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18407                 }
18408         }
18409         return NDR_ERR_SUCCESS;
18410 }
18411
18412 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
18413 {
18414         uint32_t _ptr_client;
18415         TALLOC_CTX *_mem_save_client_0;
18416         uint32_t _ptr_user;
18417         TALLOC_CTX *_mem_save_user_0;
18418         if (ndr_flags & NDR_SCALARS) {
18419                 NDR_CHECK(ndr_pull_align(ndr, 4));
18420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18421                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
18422                 if (_ptr_client) {
18423                         NDR_PULL_ALLOC(ndr, r->client);
18424                 } else {
18425                         r->client = NULL;
18426                 }
18427                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
18428                 if (_ptr_user) {
18429                         NDR_PULL_ALLOC(ndr, r->user);
18430                 } else {
18431                         r->user = NULL;
18432                 }
18433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
18434                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
18435                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
18436                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
18437         }
18438         if (ndr_flags & NDR_BUFFERS) {
18439                 if (r->client) {
18440                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
18441                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
18442                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
18443                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
18444                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
18445                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client), ndr_get_array_length(ndr, &r->client));
18446                         }
18447                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
18448                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
18449                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
18450                 }
18451                 if (r->user) {
18452                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
18453                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
18454                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
18455                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
18456                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
18457                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user), ndr_get_array_length(ndr, &r->user));
18458                         }
18459                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
18460                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
18461                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
18462                 }
18463         }
18464         return NDR_ERR_SUCCESS;
18465 }
18466
18467 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
18468 {
18469         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
18470         ndr->depth++;
18471         ndr_print_uint32(ndr, "size", r->size);
18472         ndr_print_ptr(ndr, "client", r->client);
18473         ndr->depth++;
18474         if (r->client) {
18475                 ndr_print_string(ndr, "client", r->client);
18476         }
18477         ndr->depth--;
18478         ndr_print_ptr(ndr, "user", r->user);
18479         ndr->depth++;
18480         if (r->user) {
18481                 ndr_print_string(ndr, "user", r->user);
18482         }
18483         ndr->depth--;
18484         ndr_print_uint32(ndr, "build", r->build);
18485         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
18486         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
18487         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
18488         ndr->depth--;
18489 }
18490
18491 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
18492 {
18493         if (ndr_flags & NDR_SCALARS) {
18494                 NDR_CHECK(ndr_push_align(ndr, 4));
18495                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
18496         }
18497         if (ndr_flags & NDR_BUFFERS) {
18498         }
18499         return NDR_ERR_SUCCESS;
18500 }
18501
18502 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
18503 {
18504         if (ndr_flags & NDR_SCALARS) {
18505                 NDR_CHECK(ndr_pull_align(ndr, 4));
18506                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
18507         }
18508         if (ndr_flags & NDR_BUFFERS) {
18509         }
18510         return NDR_ERR_SUCCESS;
18511 }
18512
18513 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
18514 {
18515         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
18516         ndr->depth++;
18517         ndr_print_uint32(ndr, "not_used", r->not_used);
18518         ndr->depth--;
18519 }
18520
18521 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
18522 {
18523         if (ndr_flags & NDR_SCALARS) {
18524                 NDR_CHECK(ndr_push_align(ndr, 4));
18525                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18526                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
18527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
18528                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
18529                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
18530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
18531                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
18532                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
18533                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
18534                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
18535         }
18536         if (ndr_flags & NDR_BUFFERS) {
18537                 if (r->client) {
18538                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18539                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18540                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18541                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18542                 }
18543                 if (r->user) {
18544                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18545                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18546                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18547                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18548                 }
18549         }
18550         return NDR_ERR_SUCCESS;
18551 }
18552
18553 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
18554 {
18555         uint32_t _ptr_client;
18556         TALLOC_CTX *_mem_save_client_0;
18557         uint32_t _ptr_user;
18558         TALLOC_CTX *_mem_save_user_0;
18559         if (ndr_flags & NDR_SCALARS) {
18560                 NDR_CHECK(ndr_pull_align(ndr, 4));
18561                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
18563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
18564                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
18565                 if (_ptr_client) {
18566                         NDR_PULL_ALLOC(ndr, r->client);
18567                 } else {
18568                         r->client = NULL;
18569                 }
18570                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
18571                 if (_ptr_user) {
18572                         NDR_PULL_ALLOC(ndr, r->user);
18573                 } else {
18574                         r->user = NULL;
18575                 }
18576                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
18577                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
18578                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
18579                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
18580                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
18581         }
18582         if (ndr_flags & NDR_BUFFERS) {
18583                 if (r->client) {
18584                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
18585                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
18586                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
18587                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
18588                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
18589                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client), ndr_get_array_length(ndr, &r->client));
18590                         }
18591                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
18592                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
18593                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
18594                 }
18595                 if (r->user) {
18596                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
18597                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
18598                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
18599                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
18600                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
18601                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user), ndr_get_array_length(ndr, &r->user));
18602                         }
18603                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
18604                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
18605                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
18606                 }
18607         }
18608         return NDR_ERR_SUCCESS;
18609 }
18610
18611 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
18612 {
18613         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
18614         ndr->depth++;
18615         ndr_print_uint32(ndr, "size", r->size);
18616         ndr_print_uint32(ndr, "flags", r->flags);
18617         ndr_print_uint32(ndr, "size2", r->size2);
18618         ndr_print_ptr(ndr, "client", r->client);
18619         ndr->depth++;
18620         if (r->client) {
18621                 ndr_print_string(ndr, "client", r->client);
18622         }
18623         ndr->depth--;
18624         ndr_print_ptr(ndr, "user", r->user);
18625         ndr->depth++;
18626         if (r->user) {
18627                 ndr_print_string(ndr, "user", r->user);
18628         }
18629         ndr->depth--;
18630         ndr_print_uint32(ndr, "build", r->build);
18631         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
18632         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
18633         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
18634         ndr_print_udlong(ndr, "reserved", r->reserved);
18635         ndr->depth--;
18636 }
18637
18638 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
18639 {
18640         if (ndr_flags & NDR_SCALARS) {
18641                 int level = ndr_push_get_switch_value(ndr, r);
18642                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18643                 switch (level) {
18644                         case 1: {
18645                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
18646                         break; }
18647
18648                         case 2: {
18649                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
18650                         break; }
18651
18652                         case 3: {
18653                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
18654                         break; }
18655
18656                         default:
18657                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18658                 }
18659         }
18660         if (ndr_flags & NDR_BUFFERS) {
18661                 int level = ndr_push_get_switch_value(ndr, r);
18662                 switch (level) {
18663                         case 1:
18664                                 if (r->level1) {
18665                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18666                                 }
18667                         break;
18668
18669                         case 2:
18670                                 if (r->level2) {
18671                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18672                                 }
18673                         break;
18674
18675                         case 3:
18676                                 if (r->level3) {
18677                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18678                                 }
18679                         break;
18680
18681                         default:
18682                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18683                 }
18684         }
18685         return NDR_ERR_SUCCESS;
18686 }
18687
18688 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
18689 {
18690         int level;
18691         uint32_t _level;
18692         TALLOC_CTX *_mem_save_level1_0;
18693         TALLOC_CTX *_mem_save_level2_0;
18694         TALLOC_CTX *_mem_save_level3_0;
18695         level = ndr_pull_get_switch_value(ndr, r);
18696         if (ndr_flags & NDR_SCALARS) {
18697                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18698                 if (_level != level) {
18699                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
18700                 }
18701                 switch (level) {
18702                         case 1: {
18703                                 uint32_t _ptr_level1;
18704                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
18705                                 if (_ptr_level1) {
18706                                         NDR_PULL_ALLOC(ndr, r->level1);
18707                                 } else {
18708                                         r->level1 = NULL;
18709                                 }
18710                         break; }
18711
18712                         case 2: {
18713                                 uint32_t _ptr_level2;
18714                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
18715                                 if (_ptr_level2) {
18716                                         NDR_PULL_ALLOC(ndr, r->level2);
18717                                 } else {
18718                                         r->level2 = NULL;
18719                                 }
18720                         break; }
18721
18722                         case 3: {
18723                                 uint32_t _ptr_level3;
18724                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
18725                                 if (_ptr_level3) {
18726                                         NDR_PULL_ALLOC(ndr, r->level3);
18727                                 } else {
18728                                         r->level3 = NULL;
18729                                 }
18730                         break; }
18731
18732                         default:
18733                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18734                 }
18735         }
18736         if (ndr_flags & NDR_BUFFERS) {
18737                 switch (level) {
18738                         case 1:
18739                                 if (r->level1) {
18740                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
18741                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
18742                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18743                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
18744                                 }
18745                         break;
18746
18747                         case 2:
18748                                 if (r->level2) {
18749                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
18750                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
18751                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18752                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
18753                                 }
18754                         break;
18755
18756                         case 3:
18757                                 if (r->level3) {
18758                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
18759                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
18760                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18761                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
18762                                 }
18763                         break;
18764
18765                         default:
18766                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18767                 }
18768         }
18769         return NDR_ERR_SUCCESS;
18770 }
18771
18772 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
18773 {
18774         int level;
18775         level = ndr_print_get_switch_value(ndr, r);
18776         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
18777         switch (level) {
18778                 case 1:
18779                         ndr_print_ptr(ndr, "level1", r->level1);
18780                         ndr->depth++;
18781                         if (r->level1) {
18782                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
18783                         }
18784                         ndr->depth--;
18785                 break;
18786
18787                 case 2:
18788                         ndr_print_ptr(ndr, "level2", r->level2);
18789                         ndr->depth++;
18790                         if (r->level2) {
18791                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
18792                         }
18793                         ndr->depth--;
18794                 break;
18795
18796                 case 3:
18797                         ndr_print_ptr(ndr, "level3", r->level3);
18798                         ndr->depth++;
18799                         if (r->level3) {
18800                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
18801                         }
18802                         ndr->depth--;
18803                 break;
18804
18805                 default:
18806                         ndr_print_bad_level(ndr, name, level);
18807         }
18808 }
18809
18810 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
18811 {
18812         if (ndr_flags & NDR_SCALARS) {
18813                 NDR_CHECK(ndr_push_align(ndr, 4));
18814                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
18815                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
18816                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18817         }
18818         if (ndr_flags & NDR_BUFFERS) {
18819                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18820         }
18821         return NDR_ERR_SUCCESS;
18822 }
18823
18824 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
18825 {
18826         if (ndr_flags & NDR_SCALARS) {
18827                 NDR_CHECK(ndr_pull_align(ndr, 4));
18828                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
18829                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
18830                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18831         }
18832         if (ndr_flags & NDR_BUFFERS) {
18833                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18834         }
18835         return NDR_ERR_SUCCESS;
18836 }
18837
18838 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
18839 {
18840         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
18841         ndr->depth++;
18842         ndr_print_uint32(ndr, "level", r->level);
18843         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
18844         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
18845         ndr->depth--;
18846 }
18847
18848 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18849 {
18850         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18851         return NDR_ERR_SUCCESS;
18852 }
18853
18854 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18855 {
18856         uint32_t v;
18857         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18858         *r = v;
18859         return NDR_ERR_SUCCESS;
18860 }
18861
18862 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
18863 {
18864         ndr_print_uint32(ndr, name, r);
18865         ndr->depth++;
18866         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
18867         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
18868         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
18869         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
18870         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
18871         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
18872         ndr->depth--;
18873 }
18874
18875 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
18876 {
18877         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18878         if (ndr_flags & NDR_SCALARS) {
18879                 NDR_CHECK(ndr_push_align(ndr, 4));
18880                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18881                 {
18882                         uint32_t _flags_save_string = ndr->flags;
18883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18884                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
18885                         ndr->flags = _flags_save_string;
18886                 }
18887                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
18888                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
18889                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
18890                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags)));
18891         }
18892         if (ndr_flags & NDR_BUFFERS) {
18893                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18894                 {
18895                         uint32_t _flags_save_string = ndr->flags;
18896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18897                         if (r->value_name) {
18898                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->value_name));
18899                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
18900                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->value_name));
18901                         }
18902                         ndr->flags = _flags_save_string;
18903                 }
18904                 if (r->data) {
18905                         NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data));
18906                         {
18907                                 struct ndr_push *_ndr_data;
18908                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
18909                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_data, r->data, r->type));
18910                                 NDR_CHECK(ndr_push_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
18911                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data_length));
18912                         }
18913                         NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data));
18914                 }
18915         }
18916         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18917         return NDR_ERR_SUCCESS;
18918 }
18919
18920 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
18921 {
18922         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18923         uint32_t _ptr_value_name;
18924         TALLOC_CTX *_mem_save_value_name_0;
18925         uint32_t _ptr_data;
18926         TALLOC_CTX *_mem_save_data_0;
18927         if (ndr_flags & NDR_SCALARS) {
18928                 NDR_CHECK(ndr_pull_align(ndr, 4));
18929                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18930                 {
18931                         uint32_t _flags_save_string = ndr->flags;
18932                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18933                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
18934                         if (_ptr_value_name) {
18935                                 NDR_PULL_ALLOC(ndr, r->value_name);
18936                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
18937                         } else {
18938                                 r->value_name = NULL;
18939                         }
18940                         ndr->flags = _flags_save_string;
18941                 }
18942                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
18943                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
18944                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
18945                 if (_ptr_data) {
18946                         NDR_PULL_ALLOC(ndr, r->data);
18947                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
18948                 } else {
18949                         r->data = NULL;
18950                 }
18951                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
18952         }
18953         if (ndr_flags & NDR_BUFFERS) {
18954                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18955                 {
18956                         uint32_t _flags_save_string = ndr->flags;
18957                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18958                         if (r->value_name) {
18959                                 uint32_t _relative_save_offset;
18960                                 _relative_save_offset = ndr->offset;
18961                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
18962                                 _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18963                                 NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
18964                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
18965                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
18966                                 ndr->offset = _relative_save_offset;
18967                         }
18968                         ndr->flags = _flags_save_string;
18969                 }
18970                 if (r->data) {
18971                         uint32_t _relative_save_offset;
18972                         _relative_save_offset = ndr->offset;
18973                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
18974                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
18975                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
18976                         {
18977                                 struct ndr_pull *_ndr_data;
18978                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
18979                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, r->data, r->type));
18980                                 NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
18981                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
18982                         }
18983                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
18984                         ndr->offset = _relative_save_offset;
18985                 }
18986         }
18987         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18988         return NDR_ERR_SUCCESS;
18989 }
18990
18991 _PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
18992 {
18993         ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
18994         ndr->depth++;
18995         ndr_print_ptr(ndr, "value_name", r->value_name);
18996         ndr->depth++;
18997         if (r->value_name) {
18998                 ndr_print_string(ndr, "value_name", r->value_name);
18999         }
19000         ndr->depth--;
19001         ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
19002         ndr_print_winreg_Type(ndr, "type", r->type);
19003         ndr_print_ptr(ndr, "data", r->data);
19004         ndr->depth++;
19005         if (r->data) {
19006                 ndr_print_set_switch_value(ndr, r->data, r->type);
19007                 ndr_print_spoolss_PrinterData(ndr, "data", r->data);
19008         }
19009         ndr->depth--;
19010         ndr_print_uint32(ndr, "data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags):r->data_length);
19011         ndr->depth--;
19012 }
19013
19014 _PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
19015 {
19016         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
19017 }
19018
19019 static enum ndr_err_code ndr_push_spoolss_KeyNames(struct ndr_push *ndr, int ndr_flags, const union spoolss_KeyNames *r)
19020 {
19021         if (ndr_flags & NDR_SCALARS) {
19022                 int level = ndr_push_get_switch_value(ndr, r);
19023                 switch (level) {
19024                         case 0: {
19025                         break; }
19026
19027                         case 1: {
19028                         break; }
19029
19030                         default: {
19031                                 {
19032                                         uint32_t _flags_save_string_array = ndr->flags;
19033                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19034                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
19035                                         ndr->flags = _flags_save_string_array;
19036                                 }
19037                         break; }
19038
19039                 }
19040         }
19041         if (ndr_flags & NDR_BUFFERS) {
19042                 int level = ndr_push_get_switch_value(ndr, r);
19043                 switch (level) {
19044                         case 0:
19045                         break;
19046
19047                         case 1:
19048                         break;
19049
19050                         default:
19051                         break;
19052
19053                 }
19054         }
19055         return NDR_ERR_SUCCESS;
19056 }
19057
19058 static enum ndr_err_code ndr_pull_spoolss_KeyNames(struct ndr_pull *ndr, int ndr_flags, union spoolss_KeyNames *r)
19059 {
19060         int level;
19061         level = ndr_pull_get_switch_value(ndr, r);
19062         if (ndr_flags & NDR_SCALARS) {
19063                 switch (level) {
19064                         case 0: {
19065                         break; }
19066
19067                         case 1: {
19068                         break; }
19069
19070                         default: {
19071                                 {
19072                                         uint32_t _flags_save_string_array = ndr->flags;
19073                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19074                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
19075                                         ndr->flags = _flags_save_string_array;
19076                                 }
19077                         break; }
19078
19079                 }
19080         }
19081         if (ndr_flags & NDR_BUFFERS) {
19082                 switch (level) {
19083                         case 0:
19084                         break;
19085
19086                         case 1:
19087                         break;
19088
19089                         default:
19090                         break;
19091
19092                 }
19093         }
19094         return NDR_ERR_SUCCESS;
19095 }
19096
19097 _PUBLIC_ void ndr_print_spoolss_KeyNames(struct ndr_print *ndr, const char *name, const union spoolss_KeyNames *r)
19098 {
19099         int level;
19100         level = ndr_print_get_switch_value(ndr, r);
19101         ndr_print_union(ndr, name, level, "spoolss_KeyNames");
19102         switch (level) {
19103                 case 0:
19104                 break;
19105
19106                 case 1:
19107                 break;
19108
19109                 default:
19110                         ndr_print_string_array(ndr, "string_array", r->string_array);
19111                 break;
19112
19113         }
19114 }
19115
19116 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19117 {
19118         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19119         return NDR_ERR_SUCCESS;
19120 }
19121
19122 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19123 {
19124         uint32_t v;
19125         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19126         *r = v;
19127         return NDR_ERR_SUCCESS;
19128 }
19129
19130 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19131 {
19132         ndr_print_uint32(ndr, name, r);
19133         ndr->depth++;
19134         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
19135         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
19136         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
19137         ndr->depth--;
19138 }
19139
19140 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
19141 {
19142         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19143         return NDR_ERR_SUCCESS;
19144 }
19145
19146 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
19147 {
19148         uint32_t v;
19149         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19150         *r = v;
19151         return NDR_ERR_SUCCESS;
19152 }
19153
19154 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
19155 {
19156         const char *val = NULL;
19157
19158         switch (r) {
19159                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
19160                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
19161         }
19162         ndr_print_enum(ndr, name, "ENUM", val, r);
19163 }
19164
19165 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
19166 {
19167         if (ndr_flags & NDR_SCALARS) {
19168                 NDR_CHECK(ndr_push_align(ndr, 4));
19169                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
19170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
19171                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
19172                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
19173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
19174                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
19175                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
19177                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
19178                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
19179                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
19180                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
19182                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
19183                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
19184         }
19185         if (ndr_flags & NDR_BUFFERS) {
19186         }
19187         return NDR_ERR_SUCCESS;
19188 }
19189
19190 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
19191 {
19192         if (ndr_flags & NDR_SCALARS) {
19193                 NDR_CHECK(ndr_pull_align(ndr, 4));
19194                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
19195                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19196                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
19197                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19198                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
19199                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
19200                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19201                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
19202                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
19203                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
19204                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
19205                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19206                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
19207                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
19208                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
19209         }
19210         if (ndr_flags & NDR_BUFFERS) {
19211         }
19212         return NDR_ERR_SUCCESS;
19213 }
19214
19215 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
19216 {
19217         ndr_print_struct(ndr, name, "spoolss_PortData1");
19218         ndr->depth++;
19219         ndr_print_string(ndr, "portname", r->portname);
19220         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
19221         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
19222         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
19223         ndr_print_uint32(ndr, "reserved", r->reserved);
19224         ndr_print_string(ndr, "hostaddress", r->hostaddress);
19225         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
19226         ndr_print_uint32(ndr, "dblspool", r->dblspool);
19227         ndr_print_string(ndr, "queue", r->queue);
19228         ndr_print_string(ndr, "ip_address", r->ip_address);
19229         ndr_print_string(ndr, "hardware_address", r->hardware_address);
19230         ndr_print_string(ndr, "device_type", r->device_type);
19231         ndr_print_uint32(ndr, "port_number", r->port_number);
19232         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
19233         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
19234         ndr->depth--;
19235 }
19236
19237 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
19238 {
19239         if (ndr_flags & NDR_SCALARS) {
19240                 NDR_CHECK(ndr_push_align(ndr, 4));
19241                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
19242                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
19243                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
19244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
19245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
19246                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
19247                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
19249                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
19250                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
19252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
19253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
19254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
19255         }
19256         if (ndr_flags & NDR_BUFFERS) {
19257         }
19258         return NDR_ERR_SUCCESS;
19259 }
19260
19261 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
19262 {
19263         if (ndr_flags & NDR_SCALARS) {
19264                 NDR_CHECK(ndr_pull_align(ndr, 4));
19265                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
19266                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19267                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
19268                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
19270                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
19271                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19272                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
19273                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
19274                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
19276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
19277                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
19278                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
19279         }
19280         if (ndr_flags & NDR_BUFFERS) {
19281         }
19282         return NDR_ERR_SUCCESS;
19283 }
19284
19285 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
19286 {
19287         ndr_print_struct(ndr, name, "spoolss_PortData2");
19288         ndr->depth++;
19289         ndr_print_string(ndr, "portname", r->portname);
19290         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
19291         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
19292         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
19293         ndr_print_uint32(ndr, "reserved", r->reserved);
19294         ndr_print_string(ndr, "hostaddress", r->hostaddress);
19295         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
19296         ndr_print_uint32(ndr, "dblspool", r->dblspool);
19297         ndr_print_string(ndr, "queue", r->queue);
19298         ndr_print_string(ndr, "device_type", r->device_type);
19299         ndr_print_uint32(ndr, "port_number", r->port_number);
19300         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
19301         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
19302         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
19303         ndr->depth--;
19304 }
19305
19306 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
19307 {
19308         if (ndr_flags & NDR_SCALARS) {
19309                 NDR_CHECK(ndr_push_align(ndr, 4));
19310                 {
19311                         uint32_t _flags_save_string = ndr->flags;
19312                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19313                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
19314                         ndr->flags = _flags_save_string;
19315                 }
19316         }
19317         if (ndr_flags & NDR_BUFFERS) {
19318         }
19319         return NDR_ERR_SUCCESS;
19320 }
19321
19322 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
19323 {
19324         if (ndr_flags & NDR_SCALARS) {
19325                 NDR_CHECK(ndr_pull_align(ndr, 4));
19326                 {
19327                         uint32_t _flags_save_string = ndr->flags;
19328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19329                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
19330                         ndr->flags = _flags_save_string;
19331                 }
19332         }
19333         if (ndr_flags & NDR_BUFFERS) {
19334         }
19335         return NDR_ERR_SUCCESS;
19336 }
19337
19338 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
19339 {
19340         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
19341         ndr->depth++;
19342         ndr_print_string(ndr, "dll_name", r->dll_name);
19343         ndr->depth--;
19344 }
19345
19346 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19347 {
19348         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19349         return NDR_ERR_SUCCESS;
19350 }
19351
19352 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19353 {
19354         uint32_t v;
19355         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19356         *r = v;
19357         return NDR_ERR_SUCCESS;
19358 }
19359
19360 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19361 {
19362         ndr_print_uint32(ndr, name, r);
19363         ndr->depth++;
19364         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
19365         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
19366         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
19367         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
19368         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
19369         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
19370         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
19371         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
19372         ndr->depth--;
19373 }
19374
19375 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
19376 {
19377         if (flags & NDR_IN) {
19378                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
19379                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19380                 if (r->in.server) {
19381                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19382                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19383                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19384                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19385                 }
19386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19387                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19388                 if (r->in.buffer) {
19389                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19390                 }
19391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19392         }
19393         if (flags & NDR_OUT) {
19394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19395                 if (r->out.info) {
19396                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19397                 }
19398                 if (r->out.needed == NULL) {
19399                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19400                 }
19401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19402                 if (r->out.count == NULL) {
19403                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19404                 }
19405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19406                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19407         }
19408         return NDR_ERR_SUCCESS;
19409 }
19410
19411 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
19412 {
19413         uint32_t _ptr_server;
19414         uint32_t _ptr_buffer;
19415         uint32_t _ptr_info;
19416         TALLOC_CTX *_mem_save_server_0;
19417         TALLOC_CTX *_mem_save_buffer_0;
19418         TALLOC_CTX *_mem_save_info_0;
19419         TALLOC_CTX *_mem_save_needed_0;
19420         TALLOC_CTX *_mem_save_count_0;
19421         if (flags & NDR_IN) {
19422                 ZERO_STRUCT(r->out);
19423
19424                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
19425                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
19426                 if (_ptr_server) {
19427                         NDR_PULL_ALLOC(ndr, r->in.server);
19428                 } else {
19429                         r->in.server = NULL;
19430                 }
19431                 if (r->in.server) {
19432                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
19433                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
19434                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
19435                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
19436                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
19437                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
19438                         }
19439                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
19440                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
19441                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
19442                 }
19443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19444                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19445                 if (_ptr_buffer) {
19446                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19447                 } else {
19448                         r->in.buffer = NULL;
19449                 }
19450                 if (r->in.buffer) {
19451                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19452                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19453                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19454                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19455                 }
19456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19457                 NDR_PULL_ALLOC(ndr, r->out.needed);
19458                 ZERO_STRUCTP(r->out.needed);
19459                 NDR_PULL_ALLOC(ndr, r->out.count);
19460                 ZERO_STRUCTP(r->out.count);
19461         }
19462         if (flags & NDR_OUT) {
19463                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19464                 if (_ptr_info) {
19465                         NDR_PULL_ALLOC(ndr, r->out.info);
19466                 } else {
19467                         r->out.info = NULL;
19468                 }
19469                 if (r->out.info) {
19470                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19471                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19472                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19473                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19474                 }
19475                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19476                         NDR_PULL_ALLOC(ndr, r->out.needed);
19477                 }
19478                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19479                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19480                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19481                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19482                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19483                         NDR_PULL_ALLOC(ndr, r->out.count);
19484                 }
19485                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19486                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19488                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19489                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19490         }
19491         return NDR_ERR_SUCCESS;
19492 }
19493
19494 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
19495 {
19496         uint32_t cntr_info_0;
19497         if (flags & NDR_IN) {
19498                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19499                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19500         }
19501         if (flags & NDR_OUT) {
19502                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19503                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19504                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19505                 }
19506                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19507                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19508                 }
19509         }
19510         return NDR_ERR_SUCCESS;
19511 }
19512
19513 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
19514 {
19515         uint32_t cntr_info_0;
19516         TALLOC_CTX *_mem_save_info_0;
19517         if (flags & NDR_IN) {
19518                 ZERO_STRUCT(r->out);
19519
19520                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19522         }
19523         if (flags & NDR_OUT) {
19524                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19525                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19526                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19527                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19528                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19529                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19530                 }
19531                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19532                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19533                 }
19534                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19535         }
19536         return NDR_ERR_SUCCESS;
19537 }
19538
19539 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
19540 {
19541         uint32_t cntr_info_2;
19542         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
19543         ndr->depth++;
19544         if (flags & NDR_SET_VALUES) {
19545                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19546         }
19547         if (flags & NDR_IN) {
19548                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
19549                 ndr->depth++;
19550                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
19551                 ndr_print_ptr(ndr, "server", r->in.server);
19552                 ndr->depth++;
19553                 if (r->in.server) {
19554                         ndr_print_string(ndr, "server", r->in.server);
19555                 }
19556                 ndr->depth--;
19557                 ndr_print_uint32(ndr, "level", r->in.level);
19558                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19559                 ndr->depth++;
19560                 if (r->in.buffer) {
19561                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19562                 }
19563                 ndr->depth--;
19564                 ndr_print_uint32(ndr, "offered", r->in.offered);
19565                 ndr->depth--;
19566         }
19567         if (flags & NDR_OUT) {
19568                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
19569                 ndr->depth++;
19570                 ndr_print_ptr(ndr, "count", r->out.count);
19571                 ndr->depth++;
19572                 ndr_print_uint32(ndr, "count", *r->out.count);
19573                 ndr->depth--;
19574                 ndr_print_ptr(ndr, "info", r->out.info);
19575                 ndr->depth++;
19576                 ndr_print_ptr(ndr, "info", *r->out.info);
19577                 ndr->depth++;
19578                 if (*r->out.info) {
19579                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19580                         ndr->depth++;
19581                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19582                                 char *idx_2=NULL;
19583                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19584                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19585                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19586                                         free(idx_2);
19587                                 }
19588                         }
19589                         ndr->depth--;
19590                 }
19591                 ndr->depth--;
19592                 ndr->depth--;
19593                 ndr_print_ptr(ndr, "needed", r->out.needed);
19594                 ndr->depth++;
19595                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19596                 ndr->depth--;
19597                 ndr_print_WERROR(ndr, "result", r->out.result);
19598                 ndr->depth--;
19599         }
19600         ndr->depth--;
19601 }
19602
19603 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
19604 {
19605         if (flags & NDR_IN) {
19606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
19607                 if (r->in.printername) {
19608                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
19609                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19610                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
19611                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19612                 }
19613                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
19614                 if (r->in.datatype) {
19615                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
19616                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19617                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
19618                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19619                 }
19620                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
19621                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
19622         }
19623         if (flags & NDR_OUT) {
19624                 if (r->out.handle == NULL) {
19625                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19626                 }
19627                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19628                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19629         }
19630         return NDR_ERR_SUCCESS;
19631 }
19632
19633 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
19634 {
19635         uint32_t _ptr_printername;
19636         uint32_t _ptr_datatype;
19637         TALLOC_CTX *_mem_save_printername_0;
19638         TALLOC_CTX *_mem_save_datatype_0;
19639         TALLOC_CTX *_mem_save_handle_0;
19640         if (flags & NDR_IN) {
19641                 ZERO_STRUCT(r->out);
19642
19643                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
19644                 if (_ptr_printername) {
19645                         NDR_PULL_ALLOC(ndr, r->in.printername);
19646                 } else {
19647                         r->in.printername = NULL;
19648                 }
19649                 if (r->in.printername) {
19650                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19651                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
19652                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
19653                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
19654                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
19655                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.printername), ndr_get_array_length(ndr, &r->in.printername));
19656                         }
19657                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
19658                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
19659                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
19660                 }
19661                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
19662                 if (_ptr_datatype) {
19663                         NDR_PULL_ALLOC(ndr, r->in.datatype);
19664                 } else {
19665                         r->in.datatype = NULL;
19666                 }
19667                 if (r->in.datatype) {
19668                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
19669                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
19670                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
19671                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
19672                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
19673                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.datatype), ndr_get_array_length(ndr, &r->in.datatype));
19674                         }
19675                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
19676                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
19677                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
19678                 }
19679                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
19680                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
19681                 NDR_PULL_ALLOC(ndr, r->out.handle);
19682                 ZERO_STRUCTP(r->out.handle);
19683         }
19684         if (flags & NDR_OUT) {
19685                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19686                         NDR_PULL_ALLOC(ndr, r->out.handle);
19687                 }
19688                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19689                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
19690                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19691                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19692                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19693         }
19694         return NDR_ERR_SUCCESS;
19695 }
19696
19697 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
19698 {
19699         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
19700         ndr->depth++;
19701         if (flags & NDR_SET_VALUES) {
19702                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19703         }
19704         if (flags & NDR_IN) {
19705                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
19706                 ndr->depth++;
19707                 ndr_print_ptr(ndr, "printername", r->in.printername);
19708                 ndr->depth++;
19709                 if (r->in.printername) {
19710                         ndr_print_string(ndr, "printername", r->in.printername);
19711                 }
19712                 ndr->depth--;
19713                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
19714                 ndr->depth++;
19715                 if (r->in.datatype) {
19716                         ndr_print_string(ndr, "datatype", r->in.datatype);
19717                 }
19718                 ndr->depth--;
19719                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
19720                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
19721                 ndr->depth--;
19722         }
19723         if (flags & NDR_OUT) {
19724                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
19725                 ndr->depth++;
19726                 ndr_print_ptr(ndr, "handle", r->out.handle);
19727                 ndr->depth++;
19728                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
19729                 ndr->depth--;
19730                 ndr_print_WERROR(ndr, "result", r->out.result);
19731                 ndr->depth--;
19732         }
19733         ndr->depth--;
19734 }
19735
19736 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
19737 {
19738         if (flags & NDR_IN) {
19739                 if (r->in.handle == NULL) {
19740                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19741                 }
19742                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
19744                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
19745                 if (r->in.ctr) {
19746                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
19747                 }
19748                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
19749         }
19750         if (flags & NDR_OUT) {
19751                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19752         }
19753         return NDR_ERR_SUCCESS;
19754 }
19755
19756 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
19757 {
19758         uint32_t _ptr_ctr;
19759         TALLOC_CTX *_mem_save_handle_0;
19760         TALLOC_CTX *_mem_save_ctr_0;
19761         if (flags & NDR_IN) {
19762                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19763                         NDR_PULL_ALLOC(ndr, r->in.handle);
19764                 }
19765                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19766                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19767                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19768                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19769                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
19770                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
19771                 if (_ptr_ctr) {
19772                         NDR_PULL_ALLOC(ndr, r->in.ctr);
19773                 } else {
19774                         r->in.ctr = NULL;
19775                 }
19776                 if (r->in.ctr) {
19777                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19778                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
19779                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
19780                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
19781                 }
19782                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
19783         }
19784         if (flags & NDR_OUT) {
19785                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19786         }
19787         return NDR_ERR_SUCCESS;
19788 }
19789
19790 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
19791 {
19792         ndr_print_struct(ndr, name, "spoolss_SetJob");
19793         ndr->depth++;
19794         if (flags & NDR_SET_VALUES) {
19795                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19796         }
19797         if (flags & NDR_IN) {
19798                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
19799                 ndr->depth++;
19800                 ndr_print_ptr(ndr, "handle", r->in.handle);
19801                 ndr->depth++;
19802                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19803                 ndr->depth--;
19804                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19805                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
19806                 ndr->depth++;
19807                 if (r->in.ctr) {
19808                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
19809                 }
19810                 ndr->depth--;
19811                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
19812                 ndr->depth--;
19813         }
19814         if (flags & NDR_OUT) {
19815                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
19816                 ndr->depth++;
19817                 ndr_print_WERROR(ndr, "result", r->out.result);
19818                 ndr->depth--;
19819         }
19820         ndr->depth--;
19821 }
19822
19823 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
19824 {
19825         if (flags & NDR_IN) {
19826                 if (r->in.handle == NULL) {
19827                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19828                 }
19829                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19830                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
19831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19832                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19833                 if (r->in.buffer) {
19834                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19835                 }
19836                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19837         }
19838         if (flags & NDR_OUT) {
19839                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19840                 if (r->out.info) {
19841                         {
19842                                 struct ndr_push *_ndr_info;
19843                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19844                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19845                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19846                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19847                         }
19848                 }
19849                 if (r->out.needed == NULL) {
19850                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19851                 }
19852                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19853                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19854         }
19855         return NDR_ERR_SUCCESS;
19856 }
19857
19858 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
19859 {
19860         uint32_t _ptr_buffer;
19861         uint32_t _ptr_info;
19862         TALLOC_CTX *_mem_save_handle_0;
19863         TALLOC_CTX *_mem_save_buffer_0;
19864         TALLOC_CTX *_mem_save_info_0;
19865         TALLOC_CTX *_mem_save_needed_0;
19866         if (flags & NDR_IN) {
19867                 ZERO_STRUCT(r->out);
19868
19869                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19870                         NDR_PULL_ALLOC(ndr, r->in.handle);
19871                 }
19872                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19873                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19874                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19875                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19876                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
19877                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19878                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19879                 if (_ptr_buffer) {
19880                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19881                 } else {
19882                         r->in.buffer = NULL;
19883                 }
19884                 if (r->in.buffer) {
19885                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19886                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19887                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19888                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19889                 }
19890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19891                 NDR_PULL_ALLOC(ndr, r->out.needed);
19892                 ZERO_STRUCTP(r->out.needed);
19893         }
19894         if (flags & NDR_OUT) {
19895                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19896                 if (_ptr_info) {
19897                         NDR_PULL_ALLOC(ndr, r->out.info);
19898                 } else {
19899                         r->out.info = NULL;
19900                 }
19901                 if (r->out.info) {
19902                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19903                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19904                         {
19905                                 struct ndr_pull *_ndr_info;
19906                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19907                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19908                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19909                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19910                         }
19911                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19912                 }
19913                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19914                         NDR_PULL_ALLOC(ndr, r->out.needed);
19915                 }
19916                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19917                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19918                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19919                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19920                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19921         }
19922         return NDR_ERR_SUCCESS;
19923 }
19924
19925 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
19926 {
19927         ndr_print_struct(ndr, name, "spoolss_GetJob");
19928         ndr->depth++;
19929         if (flags & NDR_SET_VALUES) {
19930                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19931         }
19932         if (flags & NDR_IN) {
19933                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
19934                 ndr->depth++;
19935                 ndr_print_ptr(ndr, "handle", r->in.handle);
19936                 ndr->depth++;
19937                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19938                 ndr->depth--;
19939                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19940                 ndr_print_uint32(ndr, "level", r->in.level);
19941                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19942                 ndr->depth++;
19943                 if (r->in.buffer) {
19944                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19945                 }
19946                 ndr->depth--;
19947                 ndr_print_uint32(ndr, "offered", r->in.offered);
19948                 ndr->depth--;
19949         }
19950         if (flags & NDR_OUT) {
19951                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
19952                 ndr->depth++;
19953                 ndr_print_ptr(ndr, "info", r->out.info);
19954                 ndr->depth++;
19955                 if (r->out.info) {
19956                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19957                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
19958                 }
19959                 ndr->depth--;
19960                 ndr_print_ptr(ndr, "needed", r->out.needed);
19961                 ndr->depth++;
19962                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19963                 ndr->depth--;
19964                 ndr_print_WERROR(ndr, "result", r->out.result);
19965                 ndr->depth--;
19966         }
19967         ndr->depth--;
19968 }
19969
19970 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
19971 {
19972         if (flags & NDR_IN) {
19973                 if (r->in.handle == NULL) {
19974                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19975                 }
19976                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19977                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
19978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
19979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19980                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19981                 if (r->in.buffer) {
19982                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19983                 }
19984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19985         }
19986         if (flags & NDR_OUT) {
19987                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19988                 if (r->out.info) {
19989                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19990                 }
19991                 if (r->out.needed == NULL) {
19992                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19993                 }
19994                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19995                 if (r->out.count == NULL) {
19996                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19997                 }
19998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19999                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20000         }
20001         return NDR_ERR_SUCCESS;
20002 }
20003
20004 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
20005 {
20006         uint32_t _ptr_buffer;
20007         uint32_t _ptr_info;
20008         TALLOC_CTX *_mem_save_handle_0;
20009         TALLOC_CTX *_mem_save_buffer_0;
20010         TALLOC_CTX *_mem_save_info_0;
20011         TALLOC_CTX *_mem_save_needed_0;
20012         TALLOC_CTX *_mem_save_count_0;
20013         if (flags & NDR_IN) {
20014                 ZERO_STRUCT(r->out);
20015
20016                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20017                         NDR_PULL_ALLOC(ndr, r->in.handle);
20018                 }
20019                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20020                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20021                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20022                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20023                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
20024                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
20025                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20026                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20027                 if (_ptr_buffer) {
20028                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20029                 } else {
20030                         r->in.buffer = NULL;
20031                 }
20032                 if (r->in.buffer) {
20033                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20034                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20035                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20036                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20037                 }
20038                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20039                 NDR_PULL_ALLOC(ndr, r->out.needed);
20040                 ZERO_STRUCTP(r->out.needed);
20041                 NDR_PULL_ALLOC(ndr, r->out.count);
20042                 ZERO_STRUCTP(r->out.count);
20043         }
20044         if (flags & NDR_OUT) {
20045                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20046                 if (_ptr_info) {
20047                         NDR_PULL_ALLOC(ndr, r->out.info);
20048                 } else {
20049                         r->out.info = NULL;
20050                 }
20051                 if (r->out.info) {
20052                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20053                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20054                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20056                 }
20057                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20058                         NDR_PULL_ALLOC(ndr, r->out.needed);
20059                 }
20060                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20061                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20063                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20064                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20065                         NDR_PULL_ALLOC(ndr, r->out.count);
20066                 }
20067                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20068                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20070                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20071                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20072         }
20073         return NDR_ERR_SUCCESS;
20074 }
20075
20076 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
20077 {
20078         uint32_t cntr_info_0;
20079         if (flags & NDR_IN) {
20080                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20082         }
20083         if (flags & NDR_OUT) {
20084                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20085                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20086                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20087                 }
20088                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20089                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20090                 }
20091         }
20092         return NDR_ERR_SUCCESS;
20093 }
20094
20095 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
20096 {
20097         uint32_t cntr_info_0;
20098         TALLOC_CTX *_mem_save_info_0;
20099         if (flags & NDR_IN) {
20100                 ZERO_STRUCT(r->out);
20101
20102                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20103                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20104         }
20105         if (flags & NDR_OUT) {
20106                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20107                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20108                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20109                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20110                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20111                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20112                 }
20113                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20114                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20115                 }
20116                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20117         }
20118         return NDR_ERR_SUCCESS;
20119 }
20120
20121 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
20122 {
20123         uint32_t cntr_info_2;
20124         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
20125         ndr->depth++;
20126         if (flags & NDR_SET_VALUES) {
20127                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20128         }
20129         if (flags & NDR_IN) {
20130                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
20131                 ndr->depth++;
20132                 ndr_print_ptr(ndr, "handle", r->in.handle);
20133                 ndr->depth++;
20134                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20135                 ndr->depth--;
20136                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
20137                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
20138                 ndr_print_uint32(ndr, "level", r->in.level);
20139                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20140                 ndr->depth++;
20141                 if (r->in.buffer) {
20142                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20143                 }
20144                 ndr->depth--;
20145                 ndr_print_uint32(ndr, "offered", r->in.offered);
20146                 ndr->depth--;
20147         }
20148         if (flags & NDR_OUT) {
20149                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
20150                 ndr->depth++;
20151                 ndr_print_ptr(ndr, "count", r->out.count);
20152                 ndr->depth++;
20153                 ndr_print_uint32(ndr, "count", *r->out.count);
20154                 ndr->depth--;
20155                 ndr_print_ptr(ndr, "info", r->out.info);
20156                 ndr->depth++;
20157                 ndr_print_ptr(ndr, "info", *r->out.info);
20158                 ndr->depth++;
20159                 if (*r->out.info) {
20160                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20161                         ndr->depth++;
20162                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20163                                 char *idx_2=NULL;
20164                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20165                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20166                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20167                                         free(idx_2);
20168                                 }
20169                         }
20170                         ndr->depth--;
20171                 }
20172                 ndr->depth--;
20173                 ndr->depth--;
20174                 ndr_print_ptr(ndr, "needed", r->out.needed);
20175                 ndr->depth++;
20176                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20177                 ndr->depth--;
20178                 ndr_print_WERROR(ndr, "result", r->out.result);
20179                 ndr->depth--;
20180         }
20181         ndr->depth--;
20182 }
20183
20184 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
20185 {
20186         if (flags & NDR_IN) {
20187         }
20188         if (flags & NDR_OUT) {
20189                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20190         }
20191         return NDR_ERR_SUCCESS;
20192 }
20193
20194 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
20195 {
20196         if (flags & NDR_IN) {
20197         }
20198         if (flags & NDR_OUT) {
20199                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20200         }
20201         return NDR_ERR_SUCCESS;
20202 }
20203
20204 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
20205 {
20206         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
20207         ndr->depth++;
20208         if (flags & NDR_SET_VALUES) {
20209                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20210         }
20211         if (flags & NDR_IN) {
20212                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
20213                 ndr->depth++;
20214                 ndr->depth--;
20215         }
20216         if (flags & NDR_OUT) {
20217                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
20218                 ndr->depth++;
20219                 ndr_print_WERROR(ndr, "result", r->out.result);
20220                 ndr->depth--;
20221         }
20222         ndr->depth--;
20223 }
20224
20225 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
20226 {
20227         if (flags & NDR_IN) {
20228                 if (r->in.handle == NULL) {
20229                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20230                 }
20231                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20232         }
20233         if (flags & NDR_OUT) {
20234                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20235         }
20236         return NDR_ERR_SUCCESS;
20237 }
20238
20239 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
20240 {
20241         TALLOC_CTX *_mem_save_handle_0;
20242         if (flags & NDR_IN) {
20243                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20244                         NDR_PULL_ALLOC(ndr, r->in.handle);
20245                 }
20246                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20247                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20248                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20249                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20250         }
20251         if (flags & NDR_OUT) {
20252                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20253         }
20254         return NDR_ERR_SUCCESS;
20255 }
20256
20257 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
20258 {
20259         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
20260         ndr->depth++;
20261         if (flags & NDR_SET_VALUES) {
20262                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20263         }
20264         if (flags & NDR_IN) {
20265                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
20266                 ndr->depth++;
20267                 ndr_print_ptr(ndr, "handle", r->in.handle);
20268                 ndr->depth++;
20269                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20270                 ndr->depth--;
20271                 ndr->depth--;
20272         }
20273         if (flags & NDR_OUT) {
20274                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
20275                 ndr->depth++;
20276                 ndr_print_WERROR(ndr, "result", r->out.result);
20277                 ndr->depth--;
20278         }
20279         ndr->depth--;
20280 }
20281
20282 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
20283 {
20284         if (flags & NDR_IN) {
20285                 if (r->in.handle == NULL) {
20286                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20287                 }
20288                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20289                 if (r->in.info_ctr == NULL) {
20290                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20291                 }
20292                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20293                 if (r->in.devmode_ctr == NULL) {
20294                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20295                 }
20296                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20297                 if (r->in.secdesc_ctr == NULL) {
20298                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20299                 }
20300                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20301                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
20302         }
20303         if (flags & NDR_OUT) {
20304                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20305         }
20306         return NDR_ERR_SUCCESS;
20307 }
20308
20309 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
20310 {
20311         TALLOC_CTX *_mem_save_handle_0;
20312         TALLOC_CTX *_mem_save_info_ctr_0;
20313         TALLOC_CTX *_mem_save_devmode_ctr_0;
20314         TALLOC_CTX *_mem_save_secdesc_ctr_0;
20315         if (flags & NDR_IN) {
20316                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20317                         NDR_PULL_ALLOC(ndr, r->in.handle);
20318                 }
20319                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20320                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20321                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20322                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20323                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20324                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20325                 }
20326                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20327                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20328                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20329                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20330                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20331                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
20332                 }
20333                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20334                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
20335                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20336                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20337                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20338                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
20339                 }
20340                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20341                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
20342                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20343                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20344                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
20345         }
20346         if (flags & NDR_OUT) {
20347                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20348         }
20349         return NDR_ERR_SUCCESS;
20350 }
20351
20352 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
20353 {
20354         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
20355         ndr->depth++;
20356         if (flags & NDR_SET_VALUES) {
20357                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20358         }
20359         if (flags & NDR_IN) {
20360                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
20361                 ndr->depth++;
20362                 ndr_print_ptr(ndr, "handle", r->in.handle);
20363                 ndr->depth++;
20364                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20365                 ndr->depth--;
20366                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
20367                 ndr->depth++;
20368                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
20369                 ndr->depth--;
20370                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
20371                 ndr->depth++;
20372                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
20373                 ndr->depth--;
20374                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20375                 ndr->depth++;
20376                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20377                 ndr->depth--;
20378                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
20379                 ndr->depth--;
20380         }
20381         if (flags & NDR_OUT) {
20382                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
20383                 ndr->depth++;
20384                 ndr_print_WERROR(ndr, "result", r->out.result);
20385                 ndr->depth--;
20386         }
20387         ndr->depth--;
20388 }
20389
20390 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
20391 {
20392         if (flags & NDR_IN) {
20393                 if (r->in.handle == NULL) {
20394                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20395                 }
20396                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20398                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20399                 if (r->in.buffer) {
20400                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20401                 }
20402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20403         }
20404         if (flags & NDR_OUT) {
20405                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20406                 if (r->out.info) {
20407                         {
20408                                 struct ndr_push *_ndr_info;
20409                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20410                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20411                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20412                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20413                         }
20414                 }
20415                 if (r->out.needed == NULL) {
20416                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20417                 }
20418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20419                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20420         }
20421         return NDR_ERR_SUCCESS;
20422 }
20423
20424 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
20425 {
20426         uint32_t _ptr_buffer;
20427         uint32_t _ptr_info;
20428         TALLOC_CTX *_mem_save_handle_0;
20429         TALLOC_CTX *_mem_save_buffer_0;
20430         TALLOC_CTX *_mem_save_info_0;
20431         TALLOC_CTX *_mem_save_needed_0;
20432         if (flags & NDR_IN) {
20433                 ZERO_STRUCT(r->out);
20434
20435                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20436                         NDR_PULL_ALLOC(ndr, r->in.handle);
20437                 }
20438                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20439                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20440                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20441                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20443                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20444                 if (_ptr_buffer) {
20445                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20446                 } else {
20447                         r->in.buffer = NULL;
20448                 }
20449                 if (r->in.buffer) {
20450                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20451                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20452                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20453                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20454                 }
20455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20456                 NDR_PULL_ALLOC(ndr, r->out.needed);
20457                 ZERO_STRUCTP(r->out.needed);
20458         }
20459         if (flags & NDR_OUT) {
20460                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20461                 if (_ptr_info) {
20462                         NDR_PULL_ALLOC(ndr, r->out.info);
20463                 } else {
20464                         r->out.info = NULL;
20465                 }
20466                 if (r->out.info) {
20467                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20468                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20469                         {
20470                                 struct ndr_pull *_ndr_info;
20471                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20472                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20473                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20474                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20475                         }
20476                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20477                 }
20478                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20479                         NDR_PULL_ALLOC(ndr, r->out.needed);
20480                 }
20481                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20482                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20484                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20485                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20486         }
20487         return NDR_ERR_SUCCESS;
20488 }
20489
20490 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
20491 {
20492         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
20493         ndr->depth++;
20494         if (flags & NDR_SET_VALUES) {
20495                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20496         }
20497         if (flags & NDR_IN) {
20498                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
20499                 ndr->depth++;
20500                 ndr_print_ptr(ndr, "handle", r->in.handle);
20501                 ndr->depth++;
20502                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20503                 ndr->depth--;
20504                 ndr_print_uint32(ndr, "level", r->in.level);
20505                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20506                 ndr->depth++;
20507                 if (r->in.buffer) {
20508                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20509                 }
20510                 ndr->depth--;
20511                 ndr_print_uint32(ndr, "offered", r->in.offered);
20512                 ndr->depth--;
20513         }
20514         if (flags & NDR_OUT) {
20515                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
20516                 ndr->depth++;
20517                 ndr_print_ptr(ndr, "info", r->out.info);
20518                 ndr->depth++;
20519                 if (r->out.info) {
20520                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20521                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
20522                 }
20523                 ndr->depth--;
20524                 ndr_print_ptr(ndr, "needed", r->out.needed);
20525                 ndr->depth++;
20526                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20527                 ndr->depth--;
20528                 ndr_print_WERROR(ndr, "result", r->out.result);
20529                 ndr->depth--;
20530         }
20531         ndr->depth--;
20532 }
20533
20534 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
20535 {
20536         if (flags & NDR_IN) {
20537                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20538                 if (r->in.servername) {
20539                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20540                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20541                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20542                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20543                 }
20544                 if (r->in.info_ctr == NULL) {
20545                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20546                 }
20547                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20548         }
20549         if (flags & NDR_OUT) {
20550                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20551         }
20552         return NDR_ERR_SUCCESS;
20553 }
20554
20555 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
20556 {
20557         uint32_t _ptr_servername;
20558         TALLOC_CTX *_mem_save_servername_0;
20559         TALLOC_CTX *_mem_save_info_ctr_0;
20560         if (flags & NDR_IN) {
20561                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20562                 if (_ptr_servername) {
20563                         NDR_PULL_ALLOC(ndr, r->in.servername);
20564                 } else {
20565                         r->in.servername = NULL;
20566                 }
20567                 if (r->in.servername) {
20568                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20569                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20570                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20571                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20572                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20573                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
20574                         }
20575                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20576                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20577                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20578                 }
20579                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20580                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20581                 }
20582                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20583                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20584                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20585                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20586         }
20587         if (flags & NDR_OUT) {
20588                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20589         }
20590         return NDR_ERR_SUCCESS;
20591 }
20592
20593 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
20594 {
20595         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
20596         ndr->depth++;
20597         if (flags & NDR_SET_VALUES) {
20598                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20599         }
20600         if (flags & NDR_IN) {
20601                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
20602                 ndr->depth++;
20603                 ndr_print_ptr(ndr, "servername", r->in.servername);
20604                 ndr->depth++;
20605                 if (r->in.servername) {
20606                         ndr_print_string(ndr, "servername", r->in.servername);
20607                 }
20608                 ndr->depth--;
20609                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
20610                 ndr->depth++;
20611                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
20612                 ndr->depth--;
20613                 ndr->depth--;
20614         }
20615         if (flags & NDR_OUT) {
20616                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
20617                 ndr->depth++;
20618                 ndr_print_WERROR(ndr, "result", r->out.result);
20619                 ndr->depth--;
20620         }
20621         ndr->depth--;
20622 }
20623
20624 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
20625 {
20626         if (flags & NDR_IN) {
20627                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20628                 if (r->in.server) {
20629                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20630                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20631                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20632                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20633                 }
20634                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20635                 if (r->in.environment) {
20636                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20637                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20638                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20639                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20640                 }
20641                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20642                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20643                 if (r->in.buffer) {
20644                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20645                 }
20646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20647         }
20648         if (flags & NDR_OUT) {
20649                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20650                 if (r->out.info) {
20651                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20652                 }
20653                 if (r->out.needed == NULL) {
20654                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20655                 }
20656                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20657                 if (r->out.count == NULL) {
20658                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20659                 }
20660                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20661                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20662         }
20663         return NDR_ERR_SUCCESS;
20664 }
20665
20666 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
20667 {
20668         uint32_t _ptr_server;
20669         uint32_t _ptr_environment;
20670         uint32_t _ptr_buffer;
20671         uint32_t _ptr_info;
20672         TALLOC_CTX *_mem_save_server_0;
20673         TALLOC_CTX *_mem_save_environment_0;
20674         TALLOC_CTX *_mem_save_buffer_0;
20675         TALLOC_CTX *_mem_save_info_0;
20676         TALLOC_CTX *_mem_save_needed_0;
20677         TALLOC_CTX *_mem_save_count_0;
20678         if (flags & NDR_IN) {
20679                 ZERO_STRUCT(r->out);
20680
20681                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20682                 if (_ptr_server) {
20683                         NDR_PULL_ALLOC(ndr, r->in.server);
20684                 } else {
20685                         r->in.server = NULL;
20686                 }
20687                 if (r->in.server) {
20688                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20689                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20690                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20691                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20692                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20693                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
20694                         }
20695                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20696                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20697                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20698                 }
20699                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20700                 if (_ptr_environment) {
20701                         NDR_PULL_ALLOC(ndr, r->in.environment);
20702                 } else {
20703                         r->in.environment = NULL;
20704                 }
20705                 if (r->in.environment) {
20706                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20707                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20708                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20709                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20710                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20711                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.environment), ndr_get_array_length(ndr, &r->in.environment));
20712                         }
20713                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20714                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20715                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20716                 }
20717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20718                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20719                 if (_ptr_buffer) {
20720                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20721                 } else {
20722                         r->in.buffer = NULL;
20723                 }
20724                 if (r->in.buffer) {
20725                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20726                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20727                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20728                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20729                 }
20730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20731                 NDR_PULL_ALLOC(ndr, r->out.needed);
20732                 ZERO_STRUCTP(r->out.needed);
20733                 NDR_PULL_ALLOC(ndr, r->out.count);
20734                 ZERO_STRUCTP(r->out.count);
20735         }
20736         if (flags & NDR_OUT) {
20737                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20738                 if (_ptr_info) {
20739                         NDR_PULL_ALLOC(ndr, r->out.info);
20740                 } else {
20741                         r->out.info = NULL;
20742                 }
20743                 if (r->out.info) {
20744                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20745                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20746                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20747                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20748                 }
20749                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20750                         NDR_PULL_ALLOC(ndr, r->out.needed);
20751                 }
20752                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20753                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20754                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20755                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20756                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20757                         NDR_PULL_ALLOC(ndr, r->out.count);
20758                 }
20759                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20760                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20761                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20762                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20763                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20764         }
20765         return NDR_ERR_SUCCESS;
20766 }
20767
20768 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
20769 {
20770         uint32_t cntr_info_0;
20771         if (flags & NDR_IN) {
20772                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20774         }
20775         if (flags & NDR_OUT) {
20776                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20777                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20778                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20779                 }
20780                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20781                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20782                 }
20783         }
20784         return NDR_ERR_SUCCESS;
20785 }
20786
20787 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
20788 {
20789         uint32_t cntr_info_0;
20790         TALLOC_CTX *_mem_save_info_0;
20791         if (flags & NDR_IN) {
20792                 ZERO_STRUCT(r->out);
20793
20794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20795                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20796         }
20797         if (flags & NDR_OUT) {
20798                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20799                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20800                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20801                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20802                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20803                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20804                 }
20805                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20806                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20807                 }
20808                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20809         }
20810         return NDR_ERR_SUCCESS;
20811 }
20812
20813 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
20814 {
20815         uint32_t cntr_info_2;
20816         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
20817         ndr->depth++;
20818         if (flags & NDR_SET_VALUES) {
20819                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20820         }
20821         if (flags & NDR_IN) {
20822                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
20823                 ndr->depth++;
20824                 ndr_print_ptr(ndr, "server", r->in.server);
20825                 ndr->depth++;
20826                 if (r->in.server) {
20827                         ndr_print_string(ndr, "server", r->in.server);
20828                 }
20829                 ndr->depth--;
20830                 ndr_print_ptr(ndr, "environment", r->in.environment);
20831                 ndr->depth++;
20832                 if (r->in.environment) {
20833                         ndr_print_string(ndr, "environment", r->in.environment);
20834                 }
20835                 ndr->depth--;
20836                 ndr_print_uint32(ndr, "level", r->in.level);
20837                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20838                 ndr->depth++;
20839                 if (r->in.buffer) {
20840                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20841                 }
20842                 ndr->depth--;
20843                 ndr_print_uint32(ndr, "offered", r->in.offered);
20844                 ndr->depth--;
20845         }
20846         if (flags & NDR_OUT) {
20847                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
20848                 ndr->depth++;
20849                 ndr_print_ptr(ndr, "count", r->out.count);
20850                 ndr->depth++;
20851                 ndr_print_uint32(ndr, "count", *r->out.count);
20852                 ndr->depth--;
20853                 ndr_print_ptr(ndr, "info", r->out.info);
20854                 ndr->depth++;
20855                 ndr_print_ptr(ndr, "info", *r->out.info);
20856                 ndr->depth++;
20857                 if (*r->out.info) {
20858                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20859                         ndr->depth++;
20860                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20861                                 char *idx_2=NULL;
20862                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20863                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20864                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20865                                         free(idx_2);
20866                                 }
20867                         }
20868                         ndr->depth--;
20869                 }
20870                 ndr->depth--;
20871                 ndr->depth--;
20872                 ndr_print_ptr(ndr, "needed", r->out.needed);
20873                 ndr->depth++;
20874                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20875                 ndr->depth--;
20876                 ndr_print_WERROR(ndr, "result", r->out.result);
20877                 ndr->depth--;
20878         }
20879         ndr->depth--;
20880 }
20881
20882 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
20883 {
20884         if (flags & NDR_IN) {
20885         }
20886         if (flags & NDR_OUT) {
20887                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20888         }
20889         return NDR_ERR_SUCCESS;
20890 }
20891
20892 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
20893 {
20894         if (flags & NDR_IN) {
20895         }
20896         if (flags & NDR_OUT) {
20897                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20898         }
20899         return NDR_ERR_SUCCESS;
20900 }
20901
20902 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
20903 {
20904         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
20905         ndr->depth++;
20906         if (flags & NDR_SET_VALUES) {
20907                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20908         }
20909         if (flags & NDR_IN) {
20910                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
20911                 ndr->depth++;
20912                 ndr->depth--;
20913         }
20914         if (flags & NDR_OUT) {
20915                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
20916                 ndr->depth++;
20917                 ndr_print_WERROR(ndr, "result", r->out.result);
20918                 ndr->depth--;
20919         }
20920         ndr->depth--;
20921 }
20922
20923 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20924 {
20925         if (flags & NDR_IN) {
20926                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20927                 if (r->in.server) {
20928                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20929                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20930                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20931                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20932                 }
20933                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20934                 if (r->in.environment) {
20935                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20936                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20937                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20938                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20939                 }
20940                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20941                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20942                 if (r->in.buffer) {
20943                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20944                 }
20945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20946         }
20947         if (flags & NDR_OUT) {
20948                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20949                 if (r->out.info) {
20950                         {
20951                                 struct ndr_push *_ndr_info;
20952                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20953                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20954                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20955                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20956                         }
20957                 }
20958                 if (r->out.needed == NULL) {
20959                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20960                 }
20961                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20962                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20963         }
20964         return NDR_ERR_SUCCESS;
20965 }
20966
20967 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
20968 {
20969         uint32_t _ptr_server;
20970         uint32_t _ptr_environment;
20971         uint32_t _ptr_buffer;
20972         uint32_t _ptr_info;
20973         TALLOC_CTX *_mem_save_server_0;
20974         TALLOC_CTX *_mem_save_environment_0;
20975         TALLOC_CTX *_mem_save_buffer_0;
20976         TALLOC_CTX *_mem_save_info_0;
20977         TALLOC_CTX *_mem_save_needed_0;
20978         if (flags & NDR_IN) {
20979                 ZERO_STRUCT(r->out);
20980
20981                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20982                 if (_ptr_server) {
20983                         NDR_PULL_ALLOC(ndr, r->in.server);
20984                 } else {
20985                         r->in.server = NULL;
20986                 }
20987                 if (r->in.server) {
20988                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20989                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20990                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20991                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20992                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20993                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
20994                         }
20995                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20996                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20997                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20998                 }
20999                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21000                 if (_ptr_environment) {
21001                         NDR_PULL_ALLOC(ndr, r->in.environment);
21002                 } else {
21003                         r->in.environment = NULL;
21004                 }
21005                 if (r->in.environment) {
21006                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21007                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21008                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21009                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21010                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21011                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.environment), ndr_get_array_length(ndr, &r->in.environment));
21012                         }
21013                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21014                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21015                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21016                 }
21017                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21018                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21019                 if (_ptr_buffer) {
21020                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21021                 } else {
21022                         r->in.buffer = NULL;
21023                 }
21024                 if (r->in.buffer) {
21025                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21026                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21027                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21028                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21029                 }
21030                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21031                 NDR_PULL_ALLOC(ndr, r->out.needed);
21032                 ZERO_STRUCTP(r->out.needed);
21033         }
21034         if (flags & NDR_OUT) {
21035                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21036                 if (_ptr_info) {
21037                         NDR_PULL_ALLOC(ndr, r->out.info);
21038                 } else {
21039                         r->out.info = NULL;
21040                 }
21041                 if (r->out.info) {
21042                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21043                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21044                         {
21045                                 struct ndr_pull *_ndr_info;
21046                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21047                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21048                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21049                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21050                         }
21051                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21052                 }
21053                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21054                         NDR_PULL_ALLOC(ndr, r->out.needed);
21055                 }
21056                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21057                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21058                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21059                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21060                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21061         }
21062         return NDR_ERR_SUCCESS;
21063 }
21064
21065 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
21066 {
21067         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
21068         ndr->depth++;
21069         if (flags & NDR_SET_VALUES) {
21070                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21071         }
21072         if (flags & NDR_IN) {
21073                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
21074                 ndr->depth++;
21075                 ndr_print_ptr(ndr, "server", r->in.server);
21076                 ndr->depth++;
21077                 if (r->in.server) {
21078                         ndr_print_string(ndr, "server", r->in.server);
21079                 }
21080                 ndr->depth--;
21081                 ndr_print_ptr(ndr, "environment", r->in.environment);
21082                 ndr->depth++;
21083                 if (r->in.environment) {
21084                         ndr_print_string(ndr, "environment", r->in.environment);
21085                 }
21086                 ndr->depth--;
21087                 ndr_print_uint32(ndr, "level", r->in.level);
21088                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21089                 ndr->depth++;
21090                 if (r->in.buffer) {
21091                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21092                 }
21093                 ndr->depth--;
21094                 ndr_print_uint32(ndr, "offered", r->in.offered);
21095                 ndr->depth--;
21096         }
21097         if (flags & NDR_OUT) {
21098                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
21099                 ndr->depth++;
21100                 ndr_print_ptr(ndr, "info", r->out.info);
21101                 ndr->depth++;
21102                 if (r->out.info) {
21103                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21104                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
21105                 }
21106                 ndr->depth--;
21107                 ndr_print_ptr(ndr, "needed", r->out.needed);
21108                 ndr->depth++;
21109                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21110                 ndr->depth--;
21111                 ndr_print_WERROR(ndr, "result", r->out.result);
21112                 ndr->depth--;
21113         }
21114         ndr->depth--;
21115 }
21116
21117 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
21118 {
21119         if (flags & NDR_IN) {
21120                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21121                 if (r->in.server) {
21122                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21125                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21126                 }
21127                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21128                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21129                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21130                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21131                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
21132                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21133                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
21134                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21135         }
21136         if (flags & NDR_OUT) {
21137                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21138         }
21139         return NDR_ERR_SUCCESS;
21140 }
21141
21142 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
21143 {
21144         uint32_t _ptr_server;
21145         TALLOC_CTX *_mem_save_server_0;
21146         if (flags & NDR_IN) {
21147                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21148                 if (_ptr_server) {
21149                         NDR_PULL_ALLOC(ndr, r->in.server);
21150                 } else {
21151                         r->in.server = NULL;
21152                 }
21153                 if (r->in.server) {
21154                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21155                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21156                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21157                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21158                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21159                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
21160                         }
21161                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21162                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21163                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21164                 }
21165                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
21166                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
21167                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
21168                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture));
21169                 }
21170                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
21171                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
21172                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
21173                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
21174                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
21175                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.driver), ndr_get_array_length(ndr, &r->in.driver));
21176                 }
21177                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
21178                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
21179         }
21180         if (flags & NDR_OUT) {
21181                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21182         }
21183         return NDR_ERR_SUCCESS;
21184 }
21185
21186 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
21187 {
21188         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
21189         ndr->depth++;
21190         if (flags & NDR_SET_VALUES) {
21191                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21192         }
21193         if (flags & NDR_IN) {
21194                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
21195                 ndr->depth++;
21196                 ndr_print_ptr(ndr, "server", r->in.server);
21197                 ndr->depth++;
21198                 if (r->in.server) {
21199                         ndr_print_string(ndr, "server", r->in.server);
21200                 }
21201                 ndr->depth--;
21202                 ndr_print_string(ndr, "architecture", r->in.architecture);
21203                 ndr_print_string(ndr, "driver", r->in.driver);
21204                 ndr->depth--;
21205         }
21206         if (flags & NDR_OUT) {
21207                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
21208                 ndr->depth++;
21209                 ndr_print_WERROR(ndr, "result", r->out.result);
21210                 ndr->depth--;
21211         }
21212         ndr->depth--;
21213 }
21214
21215 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
21216 {
21217         if (flags & NDR_IN) {
21218                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21219                 if (r->in.server) {
21220                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21221                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21222                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21223                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21224                 }
21225                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21226                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21227                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21228                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21229                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
21230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21231                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
21232                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path_name, ndr_charset_length(r->in.path_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21233                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
21234                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21235                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
21236                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.print_processor_name, ndr_charset_length(r->in.print_processor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21237         }
21238         if (flags & NDR_OUT) {
21239                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21240         }
21241         return NDR_ERR_SUCCESS;
21242 }
21243
21244 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
21245 {
21246         uint32_t _ptr_server;
21247         TALLOC_CTX *_mem_save_server_0;
21248         if (flags & NDR_IN) {
21249                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21250                 if (_ptr_server) {
21251                         NDR_PULL_ALLOC(ndr, r->in.server);
21252                 } else {
21253                         r->in.server = NULL;
21254                 }
21255                 if (r->in.server) {
21256                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21257                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21258                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21259                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21260                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21261                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
21262                         }
21263                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21264                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21265                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21266                 }
21267                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
21268                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
21269                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
21270                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture));
21271                 }
21272                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
21273                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
21274                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
21275                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
21276                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
21277                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.path_name), ndr_get_array_length(ndr, &r->in.path_name));
21278                 }
21279                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
21280                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path_name, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t), CH_UTF16));
21281                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
21282                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
21283                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
21284                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.print_processor_name), ndr_get_array_length(ndr, &r->in.print_processor_name));
21285                 }
21286                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
21287                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.print_processor_name, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t), CH_UTF16));
21288         }
21289         if (flags & NDR_OUT) {
21290                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21291         }
21292         return NDR_ERR_SUCCESS;
21293 }
21294
21295 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
21296 {
21297         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
21298         ndr->depth++;
21299         if (flags & NDR_SET_VALUES) {
21300                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21301         }
21302         if (flags & NDR_IN) {
21303                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
21304                 ndr->depth++;
21305                 ndr_print_ptr(ndr, "server", r->in.server);
21306                 ndr->depth++;
21307                 if (r->in.server) {
21308                         ndr_print_string(ndr, "server", r->in.server);
21309                 }
21310                 ndr->depth--;
21311                 ndr_print_string(ndr, "architecture", r->in.architecture);
21312                 ndr_print_string(ndr, "path_name", r->in.path_name);
21313                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
21314                 ndr->depth--;
21315         }
21316         if (flags & NDR_OUT) {
21317                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
21318                 ndr->depth++;
21319                 ndr_print_WERROR(ndr, "result", r->out.result);
21320                 ndr->depth--;
21321         }
21322         ndr->depth--;
21323 }
21324
21325 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
21326 {
21327         if (flags & NDR_IN) {
21328                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
21329                 if (r->in.servername) {
21330                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21331                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21332                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21333                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21334                 }
21335                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21336                 if (r->in.environment) {
21337                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21339                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21340                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21341                 }
21342                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21343                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21344                 if (r->in.buffer) {
21345                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21346                 }
21347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21348         }
21349         if (flags & NDR_OUT) {
21350                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21351                 if (r->out.info) {
21352                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
21353                 }
21354                 if (r->out.needed == NULL) {
21355                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21356                 }
21357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21358                 if (r->out.count == NULL) {
21359                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21360                 }
21361                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21362                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21363         }
21364         return NDR_ERR_SUCCESS;
21365 }
21366
21367 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
21368 {
21369         uint32_t _ptr_servername;
21370         uint32_t _ptr_environment;
21371         uint32_t _ptr_buffer;
21372         uint32_t _ptr_info;
21373         TALLOC_CTX *_mem_save_servername_0;
21374         TALLOC_CTX *_mem_save_environment_0;
21375         TALLOC_CTX *_mem_save_buffer_0;
21376         TALLOC_CTX *_mem_save_info_0;
21377         TALLOC_CTX *_mem_save_needed_0;
21378         TALLOC_CTX *_mem_save_count_0;
21379         if (flags & NDR_IN) {
21380                 ZERO_STRUCT(r->out);
21381
21382                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
21383                 if (_ptr_servername) {
21384                         NDR_PULL_ALLOC(ndr, r->in.servername);
21385                 } else {
21386                         r->in.servername = NULL;
21387                 }
21388                 if (r->in.servername) {
21389                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
21390                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
21391                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
21392                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
21393                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
21394                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
21395                         }
21396                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
21397                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
21398                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
21399                 }
21400                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21401                 if (_ptr_environment) {
21402                         NDR_PULL_ALLOC(ndr, r->in.environment);
21403                 } else {
21404                         r->in.environment = NULL;
21405                 }
21406                 if (r->in.environment) {
21407                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21408                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21409                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21410                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21411                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21412                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.environment), ndr_get_array_length(ndr, &r->in.environment));
21413                         }
21414                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21415                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21416                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21417                 }
21418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21419                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21420                 if (_ptr_buffer) {
21421                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21422                 } else {
21423                         r->in.buffer = NULL;
21424                 }
21425                 if (r->in.buffer) {
21426                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21427                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21428                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21429                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21430                 }
21431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21432                 NDR_PULL_ALLOC(ndr, r->out.needed);
21433                 ZERO_STRUCTP(r->out.needed);
21434                 NDR_PULL_ALLOC(ndr, r->out.count);
21435                 ZERO_STRUCTP(r->out.count);
21436         }
21437         if (flags & NDR_OUT) {
21438                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21439                 if (_ptr_info) {
21440                         NDR_PULL_ALLOC(ndr, r->out.info);
21441                 } else {
21442                         r->out.info = NULL;
21443                 }
21444                 if (r->out.info) {
21445                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21446                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21447                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
21448                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21449                 }
21450                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21451                         NDR_PULL_ALLOC(ndr, r->out.needed);
21452                 }
21453                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21454                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21456                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21457                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21458                         NDR_PULL_ALLOC(ndr, r->out.count);
21459                 }
21460                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21461                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21462                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21463                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21464                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21465         }
21466         return NDR_ERR_SUCCESS;
21467 }
21468
21469 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
21470 {
21471         uint32_t cntr_info_0;
21472         if (flags & NDR_IN) {
21473                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
21475         }
21476         if (flags & NDR_OUT) {
21477                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21478                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21479                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21480                 }
21481                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21482                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21483                 }
21484         }
21485         return NDR_ERR_SUCCESS;
21486 }
21487
21488 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
21489 {
21490         uint32_t cntr_info_0;
21491         TALLOC_CTX *_mem_save_info_0;
21492         if (flags & NDR_IN) {
21493                 ZERO_STRUCT(r->out);
21494
21495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21496                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21497         }
21498         if (flags & NDR_OUT) {
21499                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
21500                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21501                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21502                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21503                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21504                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21505                 }
21506                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21507                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21508                 }
21509                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21510         }
21511         return NDR_ERR_SUCCESS;
21512 }
21513
21514 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
21515 {
21516         uint32_t cntr_info_2;
21517         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
21518         ndr->depth++;
21519         if (flags & NDR_SET_VALUES) {
21520                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21521         }
21522         if (flags & NDR_IN) {
21523                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
21524                 ndr->depth++;
21525                 ndr_print_ptr(ndr, "servername", r->in.servername);
21526                 ndr->depth++;
21527                 if (r->in.servername) {
21528                         ndr_print_string(ndr, "servername", r->in.servername);
21529                 }
21530                 ndr->depth--;
21531                 ndr_print_ptr(ndr, "environment", r->in.environment);
21532                 ndr->depth++;
21533                 if (r->in.environment) {
21534                         ndr_print_string(ndr, "environment", r->in.environment);
21535                 }
21536                 ndr->depth--;
21537                 ndr_print_uint32(ndr, "level", r->in.level);
21538                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21539                 ndr->depth++;
21540                 if (r->in.buffer) {
21541                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21542                 }
21543                 ndr->depth--;
21544                 ndr_print_uint32(ndr, "offered", r->in.offered);
21545                 ndr->depth--;
21546         }
21547         if (flags & NDR_OUT) {
21548                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
21549                 ndr->depth++;
21550                 ndr_print_ptr(ndr, "count", r->out.count);
21551                 ndr->depth++;
21552                 ndr_print_uint32(ndr, "count", *r->out.count);
21553                 ndr->depth--;
21554                 ndr_print_ptr(ndr, "info", r->out.info);
21555                 ndr->depth++;
21556                 ndr_print_ptr(ndr, "info", *r->out.info);
21557                 ndr->depth++;
21558                 if (*r->out.info) {
21559                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21560                         ndr->depth++;
21561                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21562                                 char *idx_2=NULL;
21563                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21564                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21565                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21566                                         free(idx_2);
21567                                 }
21568                         }
21569                         ndr->depth--;
21570                 }
21571                 ndr->depth--;
21572                 ndr->depth--;
21573                 ndr_print_ptr(ndr, "needed", r->out.needed);
21574                 ndr->depth++;
21575                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21576                 ndr->depth--;
21577                 ndr_print_WERROR(ndr, "result", r->out.result);
21578                 ndr->depth--;
21579         }
21580         ndr->depth--;
21581 }
21582
21583 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
21584 {
21585         if (flags & NDR_IN) {
21586                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21587                 if (r->in.server) {
21588                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21589                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21590                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21591                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21592                 }
21593                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21594                 if (r->in.environment) {
21595                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21596                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21597                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21598                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21599                 }
21600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21601                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21602                 if (r->in.buffer) {
21603                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21604                 }
21605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21606         }
21607         if (flags & NDR_OUT) {
21608                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21609                 if (r->out.info) {
21610                         {
21611                                 struct ndr_push *_ndr_info;
21612                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21613                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21614                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21615                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21616                         }
21617                 }
21618                 if (r->out.needed == NULL) {
21619                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21620                 }
21621                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21622                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21623         }
21624         return NDR_ERR_SUCCESS;
21625 }
21626
21627 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
21628 {
21629         uint32_t _ptr_server;
21630         uint32_t _ptr_environment;
21631         uint32_t _ptr_buffer;
21632         uint32_t _ptr_info;
21633         TALLOC_CTX *_mem_save_server_0;
21634         TALLOC_CTX *_mem_save_environment_0;
21635         TALLOC_CTX *_mem_save_buffer_0;
21636         TALLOC_CTX *_mem_save_info_0;
21637         TALLOC_CTX *_mem_save_needed_0;
21638         if (flags & NDR_IN) {
21639                 ZERO_STRUCT(r->out);
21640
21641                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21642                 if (_ptr_server) {
21643                         NDR_PULL_ALLOC(ndr, r->in.server);
21644                 } else {
21645                         r->in.server = NULL;
21646                 }
21647                 if (r->in.server) {
21648                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21649                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21650                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21651                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21652                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21653                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
21654                         }
21655                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21656                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21657                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21658                 }
21659                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21660                 if (_ptr_environment) {
21661                         NDR_PULL_ALLOC(ndr, r->in.environment);
21662                 } else {
21663                         r->in.environment = NULL;
21664                 }
21665                 if (r->in.environment) {
21666                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21667                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21668                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21669                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21670                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21671                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.environment), ndr_get_array_length(ndr, &r->in.environment));
21672                         }
21673                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21674                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21675                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21676                 }
21677                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21678                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21679                 if (_ptr_buffer) {
21680                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21681                 } else {
21682                         r->in.buffer = NULL;
21683                 }
21684                 if (r->in.buffer) {
21685                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21686                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21687                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21688                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21689                 }
21690                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21691                 NDR_PULL_ALLOC(ndr, r->out.needed);
21692                 ZERO_STRUCTP(r->out.needed);
21693         }
21694         if (flags & NDR_OUT) {
21695                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21696                 if (_ptr_info) {
21697                         NDR_PULL_ALLOC(ndr, r->out.info);
21698                 } else {
21699                         r->out.info = NULL;
21700                 }
21701                 if (r->out.info) {
21702                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21703                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21704                         {
21705                                 struct ndr_pull *_ndr_info;
21706                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21707                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21708                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21709                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21710                         }
21711                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21712                 }
21713                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21714                         NDR_PULL_ALLOC(ndr, r->out.needed);
21715                 }
21716                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21717                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21719                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21720                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21721         }
21722         return NDR_ERR_SUCCESS;
21723 }
21724
21725 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
21726 {
21727         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
21728         ndr->depth++;
21729         if (flags & NDR_SET_VALUES) {
21730                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21731         }
21732         if (flags & NDR_IN) {
21733                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
21734                 ndr->depth++;
21735                 ndr_print_ptr(ndr, "server", r->in.server);
21736                 ndr->depth++;
21737                 if (r->in.server) {
21738                         ndr_print_string(ndr, "server", r->in.server);
21739                 }
21740                 ndr->depth--;
21741                 ndr_print_ptr(ndr, "environment", r->in.environment);
21742                 ndr->depth++;
21743                 if (r->in.environment) {
21744                         ndr_print_string(ndr, "environment", r->in.environment);
21745                 }
21746                 ndr->depth--;
21747                 ndr_print_uint32(ndr, "level", r->in.level);
21748                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21749                 ndr->depth++;
21750                 if (r->in.buffer) {
21751                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21752                 }
21753                 ndr->depth--;
21754                 ndr_print_uint32(ndr, "offered", r->in.offered);
21755                 ndr->depth--;
21756         }
21757         if (flags & NDR_OUT) {
21758                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
21759                 ndr->depth++;
21760                 ndr_print_ptr(ndr, "info", r->out.info);
21761                 ndr->depth++;
21762                 if (r->out.info) {
21763                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21764                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
21765                 }
21766                 ndr->depth--;
21767                 ndr_print_ptr(ndr, "needed", r->out.needed);
21768                 ndr->depth++;
21769                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21770                 ndr->depth--;
21771                 ndr_print_WERROR(ndr, "result", r->out.result);
21772                 ndr->depth--;
21773         }
21774         ndr->depth--;
21775 }
21776
21777 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
21778 {
21779         if (flags & NDR_IN) {
21780                 if (r->in.handle == NULL) {
21781                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21782                 }
21783                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21784                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21785                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
21786                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21787         }
21788         if (flags & NDR_OUT) {
21789                 if (r->out.job_id == NULL) {
21790                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21791                 }
21792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
21793                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21794         }
21795         return NDR_ERR_SUCCESS;
21796 }
21797
21798 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
21799 {
21800         TALLOC_CTX *_mem_save_handle_0;
21801         TALLOC_CTX *_mem_save_job_id_0;
21802         if (flags & NDR_IN) {
21803                 ZERO_STRUCT(r->out);
21804
21805                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21806                         NDR_PULL_ALLOC(ndr, r->in.handle);
21807                 }
21808                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21809                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21810                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21811                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21812                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21813                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
21814                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21815                 NDR_PULL_ALLOC(ndr, r->out.job_id);
21816                 ZERO_STRUCTP(r->out.job_id);
21817         }
21818         if (flags & NDR_OUT) {
21819                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21820                         NDR_PULL_ALLOC(ndr, r->out.job_id);
21821                 }
21822                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
21823                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
21824                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
21825                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
21826                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21827         }
21828         return NDR_ERR_SUCCESS;
21829 }
21830
21831 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
21832 {
21833         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
21834         ndr->depth++;
21835         if (flags & NDR_SET_VALUES) {
21836                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21837         }
21838         if (flags & NDR_IN) {
21839                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
21840                 ndr->depth++;
21841                 ndr_print_ptr(ndr, "handle", r->in.handle);
21842                 ndr->depth++;
21843                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21844                 ndr->depth--;
21845                 ndr_print_uint32(ndr, "level", r->in.level);
21846                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
21847                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
21848                 ndr->depth--;
21849         }
21850         if (flags & NDR_OUT) {
21851                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
21852                 ndr->depth++;
21853                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
21854                 ndr->depth++;
21855                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
21856                 ndr->depth--;
21857                 ndr_print_WERROR(ndr, "result", r->out.result);
21858                 ndr->depth--;
21859         }
21860         ndr->depth--;
21861 }
21862
21863 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
21864 {
21865         if (flags & NDR_IN) {
21866                 if (r->in.handle == NULL) {
21867                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21868                 }
21869                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21870         }
21871         if (flags & NDR_OUT) {
21872                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21873         }
21874         return NDR_ERR_SUCCESS;
21875 }
21876
21877 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
21878 {
21879         TALLOC_CTX *_mem_save_handle_0;
21880         if (flags & NDR_IN) {
21881                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21882                         NDR_PULL_ALLOC(ndr, r->in.handle);
21883                 }
21884                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21885                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21886                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21887                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21888         }
21889         if (flags & NDR_OUT) {
21890                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21891         }
21892         return NDR_ERR_SUCCESS;
21893 }
21894
21895 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
21896 {
21897         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
21898         ndr->depth++;
21899         if (flags & NDR_SET_VALUES) {
21900                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21901         }
21902         if (flags & NDR_IN) {
21903                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
21904                 ndr->depth++;
21905                 ndr_print_ptr(ndr, "handle", r->in.handle);
21906                 ndr->depth++;
21907                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21908                 ndr->depth--;
21909                 ndr->depth--;
21910         }
21911         if (flags & NDR_OUT) {
21912                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
21913                 ndr->depth++;
21914                 ndr_print_WERROR(ndr, "result", r->out.result);
21915                 ndr->depth--;
21916         }
21917         ndr->depth--;
21918 }
21919
21920 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
21921 {
21922         if (flags & NDR_IN) {
21923                 if (r->in.handle == NULL) {
21924                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21925                 }
21926                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21927                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21928                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
21929         }
21930         if (flags & NDR_OUT) {
21931                 if (r->out.num_written == NULL) {
21932                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21933                 }
21934                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
21935                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21936         }
21937         return NDR_ERR_SUCCESS;
21938 }
21939
21940 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
21941 {
21942         TALLOC_CTX *_mem_save_handle_0;
21943         TALLOC_CTX *_mem_save_num_written_0;
21944         if (flags & NDR_IN) {
21945                 ZERO_STRUCT(r->out);
21946
21947                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21948                         NDR_PULL_ALLOC(ndr, r->in.handle);
21949                 }
21950                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21951                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21952                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21953                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21954                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
21955                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
21956                 NDR_PULL_ALLOC(ndr, r->out.num_written);
21957                 ZERO_STRUCTP(r->out.num_written);
21958         }
21959         if (flags & NDR_OUT) {
21960                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21961                         NDR_PULL_ALLOC(ndr, r->out.num_written);
21962                 }
21963                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
21964                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
21965                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
21966                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
21967                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21968         }
21969         return NDR_ERR_SUCCESS;
21970 }
21971
21972 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
21973 {
21974         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
21975         ndr->depth++;
21976         if (flags & NDR_SET_VALUES) {
21977                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21978         }
21979         if (flags & NDR_IN) {
21980                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
21981                 ndr->depth++;
21982                 ndr_print_ptr(ndr, "handle", r->in.handle);
21983                 ndr->depth++;
21984                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21985                 ndr->depth--;
21986                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
21987                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
21988                 ndr->depth--;
21989         }
21990         if (flags & NDR_OUT) {
21991                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
21992                 ndr->depth++;
21993                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
21994                 ndr->depth++;
21995                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
21996                 ndr->depth--;
21997                 ndr_print_WERROR(ndr, "result", r->out.result);
21998                 ndr->depth--;
21999         }
22000         ndr->depth--;
22001 }
22002
22003 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
22004 {
22005         if (flags & NDR_IN) {
22006                 if (r->in.handle == NULL) {
22007                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22008                 }
22009                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22010         }
22011         if (flags & NDR_OUT) {
22012                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22013         }
22014         return NDR_ERR_SUCCESS;
22015 }
22016
22017 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
22018 {
22019         TALLOC_CTX *_mem_save_handle_0;
22020         if (flags & NDR_IN) {
22021                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22022                         NDR_PULL_ALLOC(ndr, r->in.handle);
22023                 }
22024                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22025                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22026                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22027                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22028         }
22029         if (flags & NDR_OUT) {
22030                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22031         }
22032         return NDR_ERR_SUCCESS;
22033 }
22034
22035 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
22036 {
22037         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
22038         ndr->depth++;
22039         if (flags & NDR_SET_VALUES) {
22040                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22041         }
22042         if (flags & NDR_IN) {
22043                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
22044                 ndr->depth++;
22045                 ndr_print_ptr(ndr, "handle", r->in.handle);
22046                 ndr->depth++;
22047                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22048                 ndr->depth--;
22049                 ndr->depth--;
22050         }
22051         if (flags & NDR_OUT) {
22052                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
22053                 ndr->depth++;
22054                 ndr_print_WERROR(ndr, "result", r->out.result);
22055                 ndr->depth--;
22056         }
22057         ndr->depth--;
22058 }
22059
22060 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
22061 {
22062         if (flags & NDR_IN) {
22063                 if (r->in.handle == NULL) {
22064                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22065                 }
22066                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22067         }
22068         if (flags & NDR_OUT) {
22069                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22070         }
22071         return NDR_ERR_SUCCESS;
22072 }
22073
22074 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
22075 {
22076         TALLOC_CTX *_mem_save_handle_0;
22077         if (flags & NDR_IN) {
22078                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22079                         NDR_PULL_ALLOC(ndr, r->in.handle);
22080                 }
22081                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22082                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22083                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22084                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22085         }
22086         if (flags & NDR_OUT) {
22087                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22088         }
22089         return NDR_ERR_SUCCESS;
22090 }
22091
22092 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
22093 {
22094         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
22095         ndr->depth++;
22096         if (flags & NDR_SET_VALUES) {
22097                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22098         }
22099         if (flags & NDR_IN) {
22100                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
22101                 ndr->depth++;
22102                 ndr_print_ptr(ndr, "handle", r->in.handle);
22103                 ndr->depth++;
22104                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22105                 ndr->depth--;
22106                 ndr->depth--;
22107         }
22108         if (flags & NDR_OUT) {
22109                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
22110                 ndr->depth++;
22111                 ndr_print_WERROR(ndr, "result", r->out.result);
22112                 ndr->depth--;
22113         }
22114         ndr->depth--;
22115 }
22116
22117 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
22118 {
22119         if (flags & NDR_IN) {
22120                 if (r->in.handle == NULL) {
22121                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22122                 }
22123                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22124                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
22125         }
22126         if (flags & NDR_OUT) {
22127                 if (r->out.data == NULL) {
22128                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22129                 }
22130                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
22131                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
22132                 if (r->out._data_size == NULL) {
22133                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22134                 }
22135                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
22136                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22137         }
22138         return NDR_ERR_SUCCESS;
22139 }
22140
22141 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
22142 {
22143         TALLOC_CTX *_mem_save_handle_0;
22144         TALLOC_CTX *_mem_save__data_size_0;
22145         if (flags & NDR_IN) {
22146                 ZERO_STRUCT(r->out);
22147
22148                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22149                         NDR_PULL_ALLOC(ndr, r->in.handle);
22150                 }
22151                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22152                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22153                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22154                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22155                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
22156                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
22157                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
22158                 NDR_PULL_ALLOC(ndr, r->out._data_size);
22159                 ZERO_STRUCTP(r->out._data_size);
22160         }
22161         if (flags & NDR_OUT) {
22162                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
22163                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22164                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
22165                 }
22166                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
22167                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22168                         NDR_PULL_ALLOC(ndr, r->out._data_size);
22169                 }
22170                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
22171                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
22172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
22173                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
22174                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22175                 if (r->out.data) {
22176                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
22177                 }
22178         }
22179         return NDR_ERR_SUCCESS;
22180 }
22181
22182 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
22183 {
22184         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
22185         ndr->depth++;
22186         if (flags & NDR_SET_VALUES) {
22187                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22188         }
22189         if (flags & NDR_IN) {
22190                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
22191                 ndr->depth++;
22192                 ndr_print_ptr(ndr, "handle", r->in.handle);
22193                 ndr->depth++;
22194                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22195                 ndr->depth--;
22196                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
22197                 ndr->depth--;
22198         }
22199         if (flags & NDR_OUT) {
22200                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
22201                 ndr->depth++;
22202                 ndr_print_ptr(ndr, "data", r->out.data);
22203                 ndr->depth++;
22204                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
22205                 ndr->depth--;
22206                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
22207                 ndr->depth++;
22208                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
22209                 ndr->depth--;
22210                 ndr_print_WERROR(ndr, "result", r->out.result);
22211                 ndr->depth--;
22212         }
22213         ndr->depth--;
22214 }
22215
22216 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
22217 {
22218         if (flags & NDR_IN) {
22219                 if (r->in.handle == NULL) {
22220                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22221                 }
22222                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22223         }
22224         if (flags & NDR_OUT) {
22225                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22226         }
22227         return NDR_ERR_SUCCESS;
22228 }
22229
22230 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
22231 {
22232         TALLOC_CTX *_mem_save_handle_0;
22233         if (flags & NDR_IN) {
22234                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22235                         NDR_PULL_ALLOC(ndr, r->in.handle);
22236                 }
22237                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22238                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22239                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22240                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22241         }
22242         if (flags & NDR_OUT) {
22243                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22244         }
22245         return NDR_ERR_SUCCESS;
22246 }
22247
22248 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
22249 {
22250         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
22251         ndr->depth++;
22252         if (flags & NDR_SET_VALUES) {
22253                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22254         }
22255         if (flags & NDR_IN) {
22256                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
22257                 ndr->depth++;
22258                 ndr_print_ptr(ndr, "handle", r->in.handle);
22259                 ndr->depth++;
22260                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22261                 ndr->depth--;
22262                 ndr->depth--;
22263         }
22264         if (flags & NDR_OUT) {
22265                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
22266                 ndr->depth++;
22267                 ndr_print_WERROR(ndr, "result", r->out.result);
22268                 ndr->depth--;
22269         }
22270         ndr->depth--;
22271 }
22272
22273 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
22274 {
22275         if (flags & NDR_IN) {
22276                 if (r->in.handle == NULL) {
22277                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22278                 }
22279                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22281                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22282                 if (r->in.buffer) {
22283                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22284                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
22285                 }
22286                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22287         }
22288         if (flags & NDR_OUT) {
22289                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
22290                 if (r->out.buffer) {
22291                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22292                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
22293                 }
22294                 if (r->out.needed == NULL) {
22295                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22296                 }
22297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22298                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22299         }
22300         return NDR_ERR_SUCCESS;
22301 }
22302
22303 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
22304 {
22305         uint32_t _ptr_buffer;
22306         TALLOC_CTX *_mem_save_handle_0;
22307         TALLOC_CTX *_mem_save_buffer_0;
22308         TALLOC_CTX *_mem_save_needed_0;
22309         if (flags & NDR_IN) {
22310                 ZERO_STRUCT(r->out);
22311
22312                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22313                         NDR_PULL_ALLOC(ndr, r->in.handle);
22314                 }
22315                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22316                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22317                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22318                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22319                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22320                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22321                 if (_ptr_buffer) {
22322                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22323                 } else {
22324                         r->in.buffer = NULL;
22325                 }
22326                 if (r->in.buffer) {
22327                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22328                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22329                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
22330                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
22331                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
22332                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22333                 }
22334                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22335                 NDR_PULL_ALLOC(ndr, r->out.needed);
22336                 ZERO_STRUCTP(r->out.needed);
22337                 if (r->in.buffer) {
22338                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
22339                 }
22340         }
22341         if (flags & NDR_OUT) {
22342                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22343                 if (_ptr_buffer) {
22344                         NDR_PULL_ALLOC(ndr, r->out.buffer);
22345                 } else {
22346                         r->out.buffer = NULL;
22347                 }
22348                 if (r->out.buffer) {
22349                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22350                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
22351                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
22352                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
22353                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
22354                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22355                 }
22356                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22357                         NDR_PULL_ALLOC(ndr, r->out.needed);
22358                 }
22359                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22360                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22362                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22363                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22364                 if (r->out.buffer) {
22365                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
22366                 }
22367         }
22368         return NDR_ERR_SUCCESS;
22369 }
22370
22371 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
22372 {
22373         ndr_print_struct(ndr, name, "spoolss_AddJob");
22374         ndr->depth++;
22375         if (flags & NDR_SET_VALUES) {
22376                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22377         }
22378         if (flags & NDR_IN) {
22379                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
22380                 ndr->depth++;
22381                 ndr_print_ptr(ndr, "handle", r->in.handle);
22382                 ndr->depth++;
22383                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22384                 ndr->depth--;
22385                 ndr_print_uint32(ndr, "level", r->in.level);
22386                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22387                 ndr->depth++;
22388                 if (r->in.buffer) {
22389                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
22390                 }
22391                 ndr->depth--;
22392                 ndr_print_uint32(ndr, "offered", r->in.offered);
22393                 ndr->depth--;
22394         }
22395         if (flags & NDR_OUT) {
22396                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
22397                 ndr->depth++;
22398                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
22399                 ndr->depth++;
22400                 if (r->out.buffer) {
22401                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
22402                 }
22403                 ndr->depth--;
22404                 ndr_print_ptr(ndr, "needed", r->out.needed);
22405                 ndr->depth++;
22406                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22407                 ndr->depth--;
22408                 ndr_print_WERROR(ndr, "result", r->out.result);
22409                 ndr->depth--;
22410         }
22411         ndr->depth--;
22412 }
22413
22414 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
22415 {
22416         if (flags & NDR_IN) {
22417                 if (r->in.handle == NULL) {
22418                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22419                 }
22420                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
22422         }
22423         if (flags & NDR_OUT) {
22424                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22425         }
22426         return NDR_ERR_SUCCESS;
22427 }
22428
22429 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
22430 {
22431         TALLOC_CTX *_mem_save_handle_0;
22432         if (flags & NDR_IN) {
22433                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22434                         NDR_PULL_ALLOC(ndr, r->in.handle);
22435                 }
22436                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22437                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22438                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22439                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
22441         }
22442         if (flags & NDR_OUT) {
22443                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22444         }
22445         return NDR_ERR_SUCCESS;
22446 }
22447
22448 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
22449 {
22450         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
22451         ndr->depth++;
22452         if (flags & NDR_SET_VALUES) {
22453                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22454         }
22455         if (flags & NDR_IN) {
22456                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
22457                 ndr->depth++;
22458                 ndr_print_ptr(ndr, "handle", r->in.handle);
22459                 ndr->depth++;
22460                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22461                 ndr->depth--;
22462                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
22463                 ndr->depth--;
22464         }
22465         if (flags & NDR_OUT) {
22466                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
22467                 ndr->depth++;
22468                 ndr_print_WERROR(ndr, "result", r->out.result);
22469                 ndr->depth--;
22470         }
22471         ndr->depth--;
22472 }
22473
22474 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
22475 {
22476         if (flags & NDR_IN) {
22477                 if (r->in.handle == NULL) {
22478                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22479                 }
22480                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22484                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.value_name, ndr_charset_length(r->in.value_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22486         }
22487         if (flags & NDR_OUT) {
22488                 if (r->out.type == NULL) {
22489                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22490                 }
22491                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
22492                 if (r->out.data == NULL) {
22493                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22494                 }
22495                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
22496                 if (r->out.needed == NULL) {
22497                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22498                 }
22499                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22500                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22501         }
22502         return NDR_ERR_SUCCESS;
22503 }
22504
22505 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
22506 {
22507         TALLOC_CTX *_mem_save_handle_0;
22508         TALLOC_CTX *_mem_save_type_0;
22509         TALLOC_CTX *_mem_save_data_0;
22510         TALLOC_CTX *_mem_save_needed_0;
22511         if (flags & NDR_IN) {
22512                 ZERO_STRUCT(r->out);
22513
22514                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22515                         NDR_PULL_ALLOC(ndr, r->in.handle);
22516                 }
22517                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22518                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22519                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22520                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22521                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22522                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22523                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22524                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
22525                 }
22526                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22527                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t), CH_UTF16));
22528                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22529                 NDR_PULL_ALLOC(ndr, r->out.type);
22530                 ZERO_STRUCTP(r->out.type);
22531                 NDR_PULL_ALLOC(ndr, r->out.data);
22532                 ZERO_STRUCTP(r->out.data);
22533                 NDR_PULL_ALLOC(ndr, r->out.needed);
22534                 ZERO_STRUCTP(r->out.needed);
22535         }
22536         if (flags & NDR_OUT) {
22537                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22538                         NDR_PULL_ALLOC(ndr, r->out.type);
22539                 }
22540                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
22541                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
22542                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
22543                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
22544                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22545                         NDR_PULL_ALLOC(ndr, r->out.data);
22546                 }
22547                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
22548                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
22549                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
22550                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
22551                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22552                         NDR_PULL_ALLOC(ndr, r->out.needed);
22553                 }
22554                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22555                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22556                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22557                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22558                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22559         }
22560         return NDR_ERR_SUCCESS;
22561 }
22562
22563 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
22564 {
22565         if (flags & NDR_IN) {
22566                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22567         }
22568         if (flags & NDR_OUT) {
22569                 if (r->out.data == NULL) {
22570                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22571                 }
22572                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
22573                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
22574         }
22575         return NDR_ERR_SUCCESS;
22576 }
22577
22578 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
22579 {
22580         TALLOC_CTX *_mem_save_data_0;
22581         if (flags & NDR_IN) {
22582                 ZERO_STRUCT(r->out);
22583
22584                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
22585                 NDR_PULL_ALLOC(ndr, r->out.data);
22586                 ZERO_STRUCTP(r->out.data);
22587         }
22588         if (flags & NDR_OUT) {
22589                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22590                         NDR_PULL_ALLOC(ndr, r->out.data);
22591                 }
22592                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
22593                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
22594                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
22595                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
22596                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
22597         }
22598         return NDR_ERR_SUCCESS;
22599 }
22600
22601 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
22602 {
22603         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
22604         ndr->depth++;
22605         if (flags & NDR_SET_VALUES) {
22606                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22607         }
22608         if (flags & NDR_IN) {
22609                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
22610                 ndr->depth++;
22611                 ndr_print_ptr(ndr, "handle", r->in.handle);
22612                 ndr->depth++;
22613                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22614                 ndr->depth--;
22615                 ndr_print_string(ndr, "value_name", r->in.value_name);
22616                 ndr_print_uint32(ndr, "offered", r->in.offered);
22617                 ndr->depth--;
22618         }
22619         if (flags & NDR_OUT) {
22620                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
22621                 ndr->depth++;
22622                 ndr_print_ptr(ndr, "type", r->out.type);
22623                 ndr->depth++;
22624                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
22625                 ndr->depth--;
22626                 ndr_print_ptr(ndr, "data", r->out.data);
22627                 ndr->depth++;
22628                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
22629                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
22630                 ndr->depth--;
22631                 ndr_print_ptr(ndr, "needed", r->out.needed);
22632                 ndr->depth++;
22633                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22634                 ndr->depth--;
22635                 ndr_print_WERROR(ndr, "result", r->out.result);
22636                 ndr->depth--;
22637         }
22638         ndr->depth--;
22639 }
22640
22641 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
22642 {
22643         if (flags & NDR_IN) {
22644                 if (r->in.handle == NULL) {
22645                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22646                 }
22647                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22648                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22650                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22651                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.value_name, ndr_charset_length(r->in.value_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22652                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22653                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
22654                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
22655         }
22656         if (flags & NDR_OUT) {
22657                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22658         }
22659         return NDR_ERR_SUCCESS;
22660 }
22661
22662 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
22663 {
22664         if (flags & NDR_IN) {
22665                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22666         }
22667         if (flags & NDR_OUT) {
22668                 if (r->out.data == NULL) {
22669                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22670                 }
22671                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
22672                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
22673         }
22674         return NDR_ERR_SUCCESS;
22675 }
22676
22677 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
22678 {
22679         TALLOC_CTX *_mem_save_handle_0;
22680         if (flags & NDR_IN) {
22681                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22682                         NDR_PULL_ALLOC(ndr, r->in.handle);
22683                 }
22684                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22685                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22686                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22687                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22688                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22689                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22690                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22691                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
22692                 }
22693                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22694                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t), CH_UTF16));
22695                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
22696                 {
22697                         struct ndr_pull *_ndr_data;
22698                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
22699                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
22700                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
22701                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
22702                 }
22703                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
22704         }
22705         if (flags & NDR_OUT) {
22706                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22707         }
22708         return NDR_ERR_SUCCESS;
22709 }
22710
22711 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
22712 {
22713         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
22714         ndr->depth++;
22715         if (flags & NDR_SET_VALUES) {
22716                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22717         }
22718         if (flags & NDR_IN) {
22719                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
22720                 ndr->depth++;
22721                 ndr_print_ptr(ndr, "handle", r->in.handle);
22722                 ndr->depth++;
22723                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22724                 ndr->depth--;
22725                 ndr_print_string(ndr, "value_name", r->in.value_name);
22726                 ndr_print_winreg_Type(ndr, "type", r->in.type);
22727                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
22728                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
22729                 ndr_print_uint32(ndr, "_offered", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_PrinterData(&r->in.data, r->in.type, ndr->iconv_convenience, flags):r->in._offered);
22730                 ndr->depth--;
22731         }
22732         if (flags & NDR_OUT) {
22733                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
22734                 ndr->depth++;
22735                 ndr_print_WERROR(ndr, "result", r->out.result);
22736                 ndr->depth--;
22737         }
22738         ndr->depth--;
22739 }
22740
22741 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
22742 {
22743         if (flags & NDR_IN) {
22744         }
22745         if (flags & NDR_OUT) {
22746                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22747         }
22748         return NDR_ERR_SUCCESS;
22749 }
22750
22751 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
22752 {
22753         if (flags & NDR_IN) {
22754         }
22755         if (flags & NDR_OUT) {
22756                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22757         }
22758         return NDR_ERR_SUCCESS;
22759 }
22760
22761 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
22762 {
22763         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
22764         ndr->depth++;
22765         if (flags & NDR_SET_VALUES) {
22766                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22767         }
22768         if (flags & NDR_IN) {
22769                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
22770                 ndr->depth++;
22771                 ndr->depth--;
22772         }
22773         if (flags & NDR_OUT) {
22774                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
22775                 ndr->depth++;
22776                 ndr_print_WERROR(ndr, "result", r->out.result);
22777                 ndr->depth--;
22778         }
22779         ndr->depth--;
22780 }
22781
22782 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
22783 {
22784         if (flags & NDR_IN) {
22785                 if (r->in.handle == NULL) {
22786                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22787                 }
22788                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22789         }
22790         if (flags & NDR_OUT) {
22791                 if (r->out.handle == NULL) {
22792                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22793                 }
22794                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
22795                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22796         }
22797         return NDR_ERR_SUCCESS;
22798 }
22799
22800 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
22801 {
22802         TALLOC_CTX *_mem_save_handle_0;
22803         if (flags & NDR_IN) {
22804                 ZERO_STRUCT(r->out);
22805
22806                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22807                         NDR_PULL_ALLOC(ndr, r->in.handle);
22808                 }
22809                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22810                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22811                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22812                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22813                 NDR_PULL_ALLOC(ndr, r->out.handle);
22814                 *r->out.handle = *r->in.handle;
22815         }
22816         if (flags & NDR_OUT) {
22817                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22818                         NDR_PULL_ALLOC(ndr, r->out.handle);
22819                 }
22820                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22821                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
22822                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
22823                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22824                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22825         }
22826         return NDR_ERR_SUCCESS;
22827 }
22828
22829 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
22830 {
22831         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
22832         ndr->depth++;
22833         if (flags & NDR_SET_VALUES) {
22834                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22835         }
22836         if (flags & NDR_IN) {
22837                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
22838                 ndr->depth++;
22839                 ndr_print_ptr(ndr, "handle", r->in.handle);
22840                 ndr->depth++;
22841                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22842                 ndr->depth--;
22843                 ndr->depth--;
22844         }
22845         if (flags & NDR_OUT) {
22846                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
22847                 ndr->depth++;
22848                 ndr_print_ptr(ndr, "handle", r->out.handle);
22849                 ndr->depth++;
22850                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
22851                 ndr->depth--;
22852                 ndr_print_WERROR(ndr, "result", r->out.result);
22853                 ndr->depth--;
22854         }
22855         ndr->depth--;
22856 }
22857
22858 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
22859 {
22860         if (flags & NDR_IN) {
22861                 if (r->in.handle == NULL) {
22862                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22863                 }
22864                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22865                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22866                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22867                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22868         }
22869         if (flags & NDR_OUT) {
22870                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22871         }
22872         return NDR_ERR_SUCCESS;
22873 }
22874
22875 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
22876 {
22877         TALLOC_CTX *_mem_save_handle_0;
22878         if (flags & NDR_IN) {
22879                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22880                         NDR_PULL_ALLOC(ndr, r->in.handle);
22881                 }
22882                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22883                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22884                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22885                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22886                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22887                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22888                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22889         }
22890         if (flags & NDR_OUT) {
22891                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22892         }
22893         return NDR_ERR_SUCCESS;
22894 }
22895
22896 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
22897 {
22898         ndr_print_struct(ndr, name, "spoolss_AddForm");
22899         ndr->depth++;
22900         if (flags & NDR_SET_VALUES) {
22901                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22902         }
22903         if (flags & NDR_IN) {
22904                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
22905                 ndr->depth++;
22906                 ndr_print_ptr(ndr, "handle", r->in.handle);
22907                 ndr->depth++;
22908                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22909                 ndr->depth--;
22910                 ndr_print_uint32(ndr, "level", r->in.level);
22911                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22912                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22913                 ndr->depth--;
22914         }
22915         if (flags & NDR_OUT) {
22916                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
22917                 ndr->depth++;
22918                 ndr_print_WERROR(ndr, "result", r->out.result);
22919                 ndr->depth--;
22920         }
22921         ndr->depth--;
22922 }
22923
22924 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
22925 {
22926         if (flags & NDR_IN) {
22927                 if (r->in.handle == NULL) {
22928                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22929                 }
22930                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22931                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22932                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22934                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.form_name, ndr_charset_length(r->in.form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22935         }
22936         if (flags & NDR_OUT) {
22937                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22938         }
22939         return NDR_ERR_SUCCESS;
22940 }
22941
22942 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
22943 {
22944         TALLOC_CTX *_mem_save_handle_0;
22945         if (flags & NDR_IN) {
22946                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22947                         NDR_PULL_ALLOC(ndr, r->in.handle);
22948                 }
22949                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22950                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22951                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22952                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22953                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22954                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22955                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22956                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.form_name), ndr_get_array_length(ndr, &r->in.form_name));
22957                 }
22958                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22959                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.form_name, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t), CH_UTF16));
22960         }
22961         if (flags & NDR_OUT) {
22962                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22963         }
22964         return NDR_ERR_SUCCESS;
22965 }
22966
22967 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
22968 {
22969         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
22970         ndr->depth++;
22971         if (flags & NDR_SET_VALUES) {
22972                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22973         }
22974         if (flags & NDR_IN) {
22975                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
22976                 ndr->depth++;
22977                 ndr_print_ptr(ndr, "handle", r->in.handle);
22978                 ndr->depth++;
22979                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22980                 ndr->depth--;
22981                 ndr_print_string(ndr, "form_name", r->in.form_name);
22982                 ndr->depth--;
22983         }
22984         if (flags & NDR_OUT) {
22985                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
22986                 ndr->depth++;
22987                 ndr_print_WERROR(ndr, "result", r->out.result);
22988                 ndr->depth--;
22989         }
22990         ndr->depth--;
22991 }
22992
22993 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
22994 {
22995         if (flags & NDR_IN) {
22996                 if (r->in.handle == NULL) {
22997                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22998                 }
22999                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23001                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23002                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23003                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.form_name, ndr_charset_length(r->in.form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23004                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23005                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23006                 if (r->in.buffer) {
23007                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23008                 }
23009                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23010         }
23011         if (flags & NDR_OUT) {
23012                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23013                 if (r->out.info) {
23014                         {
23015                                 struct ndr_push *_ndr_info;
23016                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23017                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
23018                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23019                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23020                         }
23021                 }
23022                 if (r->out.needed == NULL) {
23023                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23024                 }
23025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23026                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23027         }
23028         return NDR_ERR_SUCCESS;
23029 }
23030
23031 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
23032 {
23033         uint32_t _ptr_buffer;
23034         uint32_t _ptr_info;
23035         TALLOC_CTX *_mem_save_handle_0;
23036         TALLOC_CTX *_mem_save_buffer_0;
23037         TALLOC_CTX *_mem_save_info_0;
23038         TALLOC_CTX *_mem_save_needed_0;
23039         if (flags & NDR_IN) {
23040                 ZERO_STRUCT(r->out);
23041
23042                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23043                         NDR_PULL_ALLOC(ndr, r->in.handle);
23044                 }
23045                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23046                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23047                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23048                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23049                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23050                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23051                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23052                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.form_name), ndr_get_array_length(ndr, &r->in.form_name));
23053                 }
23054                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23055                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.form_name, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t), CH_UTF16));
23056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23057                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23058                 if (_ptr_buffer) {
23059                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23060                 } else {
23061                         r->in.buffer = NULL;
23062                 }
23063                 if (r->in.buffer) {
23064                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23065                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23066                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23068                 }
23069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23070                 NDR_PULL_ALLOC(ndr, r->out.needed);
23071                 ZERO_STRUCTP(r->out.needed);
23072         }
23073         if (flags & NDR_OUT) {
23074                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23075                 if (_ptr_info) {
23076                         NDR_PULL_ALLOC(ndr, r->out.info);
23077                 } else {
23078                         r->out.info = NULL;
23079                 }
23080                 if (r->out.info) {
23081                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23082                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23083                         {
23084                                 struct ndr_pull *_ndr_info;
23085                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23086                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
23087                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23088                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23089                         }
23090                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23091                 }
23092                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23093                         NDR_PULL_ALLOC(ndr, r->out.needed);
23094                 }
23095                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23096                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23097                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23098                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23099                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23100         }
23101         return NDR_ERR_SUCCESS;
23102 }
23103
23104 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
23105 {
23106         ndr_print_struct(ndr, name, "spoolss_GetForm");
23107         ndr->depth++;
23108         if (flags & NDR_SET_VALUES) {
23109                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23110         }
23111         if (flags & NDR_IN) {
23112                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
23113                 ndr->depth++;
23114                 ndr_print_ptr(ndr, "handle", r->in.handle);
23115                 ndr->depth++;
23116                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23117                 ndr->depth--;
23118                 ndr_print_string(ndr, "form_name", r->in.form_name);
23119                 ndr_print_uint32(ndr, "level", r->in.level);
23120                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23121                 ndr->depth++;
23122                 if (r->in.buffer) {
23123                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23124                 }
23125                 ndr->depth--;
23126                 ndr_print_uint32(ndr, "offered", r->in.offered);
23127                 ndr->depth--;
23128         }
23129         if (flags & NDR_OUT) {
23130                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
23131                 ndr->depth++;
23132                 ndr_print_ptr(ndr, "info", r->out.info);
23133                 ndr->depth++;
23134                 if (r->out.info) {
23135                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
23136                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
23137                 }
23138                 ndr->depth--;
23139                 ndr_print_ptr(ndr, "needed", r->out.needed);
23140                 ndr->depth++;
23141                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23142                 ndr->depth--;
23143                 ndr_print_WERROR(ndr, "result", r->out.result);
23144                 ndr->depth--;
23145         }
23146         ndr->depth--;
23147 }
23148
23149 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
23150 {
23151         if (flags & NDR_IN) {
23152                 if (r->in.handle == NULL) {
23153                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23154                 }
23155                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23157                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23158                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23159                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.form_name, ndr_charset_length(r->in.form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23160                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23161                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
23162                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23163         }
23164         if (flags & NDR_OUT) {
23165                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23166         }
23167         return NDR_ERR_SUCCESS;
23168 }
23169
23170 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
23171 {
23172         TALLOC_CTX *_mem_save_handle_0;
23173         if (flags & NDR_IN) {
23174                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23175                         NDR_PULL_ALLOC(ndr, r->in.handle);
23176                 }
23177                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23178                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23179                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23180                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23181                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23182                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23183                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23184                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.form_name), ndr_get_array_length(ndr, &r->in.form_name));
23185                 }
23186                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23187                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.form_name, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t), CH_UTF16));
23188                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23189                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23190                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23191         }
23192         if (flags & NDR_OUT) {
23193                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23194         }
23195         return NDR_ERR_SUCCESS;
23196 }
23197
23198 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
23199 {
23200         ndr_print_struct(ndr, name, "spoolss_SetForm");
23201         ndr->depth++;
23202         if (flags & NDR_SET_VALUES) {
23203                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23204         }
23205         if (flags & NDR_IN) {
23206                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
23207                 ndr->depth++;
23208                 ndr_print_ptr(ndr, "handle", r->in.handle);
23209                 ndr->depth++;
23210                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23211                 ndr->depth--;
23212                 ndr_print_string(ndr, "form_name", r->in.form_name);
23213                 ndr_print_uint32(ndr, "level", r->in.level);
23214                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
23215                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
23216                 ndr->depth--;
23217         }
23218         if (flags & NDR_OUT) {
23219                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
23220                 ndr->depth++;
23221                 ndr_print_WERROR(ndr, "result", r->out.result);
23222                 ndr->depth--;
23223         }
23224         ndr->depth--;
23225 }
23226
23227 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
23228 {
23229         if (flags & NDR_IN) {
23230                 if (r->in.handle == NULL) {
23231                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23232                 }
23233                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23234                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23235                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23236                 if (r->in.buffer) {
23237                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23238                 }
23239                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23240         }
23241         if (flags & NDR_OUT) {
23242                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23243                 if (r->out.info) {
23244                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23245                 }
23246                 if (r->out.needed == NULL) {
23247                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23248                 }
23249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23250                 if (r->out.count == NULL) {
23251                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23252                 }
23253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23254                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23255         }
23256         return NDR_ERR_SUCCESS;
23257 }
23258
23259 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
23260 {
23261         uint32_t _ptr_buffer;
23262         uint32_t _ptr_info;
23263         TALLOC_CTX *_mem_save_handle_0;
23264         TALLOC_CTX *_mem_save_buffer_0;
23265         TALLOC_CTX *_mem_save_info_0;
23266         TALLOC_CTX *_mem_save_needed_0;
23267         TALLOC_CTX *_mem_save_count_0;
23268         if (flags & NDR_IN) {
23269                 ZERO_STRUCT(r->out);
23270
23271                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23272                         NDR_PULL_ALLOC(ndr, r->in.handle);
23273                 }
23274                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23275                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23276                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23277                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23278                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23279                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23280                 if (_ptr_buffer) {
23281                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23282                 } else {
23283                         r->in.buffer = NULL;
23284                 }
23285                 if (r->in.buffer) {
23286                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23287                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23288                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23289                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23290                 }
23291                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23292                 NDR_PULL_ALLOC(ndr, r->out.needed);
23293                 ZERO_STRUCTP(r->out.needed);
23294                 NDR_PULL_ALLOC(ndr, r->out.count);
23295                 ZERO_STRUCTP(r->out.count);
23296         }
23297         if (flags & NDR_OUT) {
23298                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23299                 if (_ptr_info) {
23300                         NDR_PULL_ALLOC(ndr, r->out.info);
23301                 } else {
23302                         r->out.info = NULL;
23303                 }
23304                 if (r->out.info) {
23305                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23306                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23307                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23308                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23309                 }
23310                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23311                         NDR_PULL_ALLOC(ndr, r->out.needed);
23312                 }
23313                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23314                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23315                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23316                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23317                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23318                         NDR_PULL_ALLOC(ndr, r->out.count);
23319                 }
23320                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23321                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23322                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23323                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23324                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23325         }
23326         return NDR_ERR_SUCCESS;
23327 }
23328
23329 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
23330 {
23331         uint32_t cntr_info_0;
23332         if (flags & NDR_IN) {
23333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23335         }
23336         if (flags & NDR_OUT) {
23337                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23338                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23339                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23340                 }
23341                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23342                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23343                 }
23344         }
23345         return NDR_ERR_SUCCESS;
23346 }
23347
23348 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
23349 {
23350         uint32_t cntr_info_0;
23351         TALLOC_CTX *_mem_save_info_0;
23352         if (flags & NDR_IN) {
23353                 ZERO_STRUCT(r->out);
23354
23355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23357         }
23358         if (flags & NDR_OUT) {
23359                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23360                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23361                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23362                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23363                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23364                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23365                 }
23366                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23367                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23368                 }
23369                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23370         }
23371         return NDR_ERR_SUCCESS;
23372 }
23373
23374 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
23375 {
23376         uint32_t cntr_info_2;
23377         ndr_print_struct(ndr, name, "spoolss_EnumForms");
23378         ndr->depth++;
23379         if (flags & NDR_SET_VALUES) {
23380                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23381         }
23382         if (flags & NDR_IN) {
23383                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
23384                 ndr->depth++;
23385                 ndr_print_ptr(ndr, "handle", r->in.handle);
23386                 ndr->depth++;
23387                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23388                 ndr->depth--;
23389                 ndr_print_uint32(ndr, "level", r->in.level);
23390                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23391                 ndr->depth++;
23392                 if (r->in.buffer) {
23393                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23394                 }
23395                 ndr->depth--;
23396                 ndr_print_uint32(ndr, "offered", r->in.offered);
23397                 ndr->depth--;
23398         }
23399         if (flags & NDR_OUT) {
23400                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
23401                 ndr->depth++;
23402                 ndr_print_ptr(ndr, "count", r->out.count);
23403                 ndr->depth++;
23404                 ndr_print_uint32(ndr, "count", *r->out.count);
23405                 ndr->depth--;
23406                 ndr_print_ptr(ndr, "info", r->out.info);
23407                 ndr->depth++;
23408                 ndr_print_ptr(ndr, "info", *r->out.info);
23409                 ndr->depth++;
23410                 if (*r->out.info) {
23411                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23412                         ndr->depth++;
23413                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23414                                 char *idx_2=NULL;
23415                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23416                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23417                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23418                                         free(idx_2);
23419                                 }
23420                         }
23421                         ndr->depth--;
23422                 }
23423                 ndr->depth--;
23424                 ndr->depth--;
23425                 ndr_print_ptr(ndr, "needed", r->out.needed);
23426                 ndr->depth++;
23427                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23428                 ndr->depth--;
23429                 ndr_print_WERROR(ndr, "result", r->out.result);
23430                 ndr->depth--;
23431         }
23432         ndr->depth--;
23433 }
23434
23435 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
23436 {
23437         if (flags & NDR_IN) {
23438                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23439                 if (r->in.servername) {
23440                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23441                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23443                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23444                 }
23445                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23446                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23447                 if (r->in.buffer) {
23448                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23449                 }
23450                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23451         }
23452         if (flags & NDR_OUT) {
23453                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23454                 if (r->out.info) {
23455                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23456                 }
23457                 if (r->out.needed == NULL) {
23458                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23459                 }
23460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23461                 if (r->out.count == NULL) {
23462                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23463                 }
23464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23465                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23466         }
23467         return NDR_ERR_SUCCESS;
23468 }
23469
23470 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
23471 {
23472         uint32_t _ptr_servername;
23473         uint32_t _ptr_buffer;
23474         uint32_t _ptr_info;
23475         TALLOC_CTX *_mem_save_servername_0;
23476         TALLOC_CTX *_mem_save_buffer_0;
23477         TALLOC_CTX *_mem_save_info_0;
23478         TALLOC_CTX *_mem_save_needed_0;
23479         TALLOC_CTX *_mem_save_count_0;
23480         if (flags & NDR_IN) {
23481                 ZERO_STRUCT(r->out);
23482
23483                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23484                 if (_ptr_servername) {
23485                         NDR_PULL_ALLOC(ndr, r->in.servername);
23486                 } else {
23487                         r->in.servername = NULL;
23488                 }
23489                 if (r->in.servername) {
23490                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23491                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23492                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23493                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23494                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23495                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
23496                         }
23497                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23498                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23499                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23500                 }
23501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23502                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23503                 if (_ptr_buffer) {
23504                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23505                 } else {
23506                         r->in.buffer = NULL;
23507                 }
23508                 if (r->in.buffer) {
23509                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23510                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23511                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23512                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23513                 }
23514                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23515                 NDR_PULL_ALLOC(ndr, r->out.needed);
23516                 ZERO_STRUCTP(r->out.needed);
23517                 NDR_PULL_ALLOC(ndr, r->out.count);
23518                 ZERO_STRUCTP(r->out.count);
23519         }
23520         if (flags & NDR_OUT) {
23521                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23522                 if (_ptr_info) {
23523                         NDR_PULL_ALLOC(ndr, r->out.info);
23524                 } else {
23525                         r->out.info = NULL;
23526                 }
23527                 if (r->out.info) {
23528                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23529                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23530                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23531                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23532                 }
23533                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23534                         NDR_PULL_ALLOC(ndr, r->out.needed);
23535                 }
23536                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23537                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23539                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23540                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23541                         NDR_PULL_ALLOC(ndr, r->out.count);
23542                 }
23543                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23544                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23546                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23547                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23548         }
23549         return NDR_ERR_SUCCESS;
23550 }
23551
23552 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
23553 {
23554         uint32_t cntr_info_0;
23555         if (flags & NDR_IN) {
23556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23558         }
23559         if (flags & NDR_OUT) {
23560                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23561                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23562                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23563                 }
23564                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23565                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23566                 }
23567         }
23568         return NDR_ERR_SUCCESS;
23569 }
23570
23571 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
23572 {
23573         uint32_t cntr_info_0;
23574         TALLOC_CTX *_mem_save_info_0;
23575         if (flags & NDR_IN) {
23576                 ZERO_STRUCT(r->out);
23577
23578                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23579                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23580         }
23581         if (flags & NDR_OUT) {
23582                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23583                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23584                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23585                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23586                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23587                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23588                 }
23589                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23590                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23591                 }
23592                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23593         }
23594         return NDR_ERR_SUCCESS;
23595 }
23596
23597 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
23598 {
23599         uint32_t cntr_info_2;
23600         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
23601         ndr->depth++;
23602         if (flags & NDR_SET_VALUES) {
23603                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23604         }
23605         if (flags & NDR_IN) {
23606                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
23607                 ndr->depth++;
23608                 ndr_print_ptr(ndr, "servername", r->in.servername);
23609                 ndr->depth++;
23610                 if (r->in.servername) {
23611                         ndr_print_string(ndr, "servername", r->in.servername);
23612                 }
23613                 ndr->depth--;
23614                 ndr_print_uint32(ndr, "level", r->in.level);
23615                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23616                 ndr->depth++;
23617                 if (r->in.buffer) {
23618                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23619                 }
23620                 ndr->depth--;
23621                 ndr_print_uint32(ndr, "offered", r->in.offered);
23622                 ndr->depth--;
23623         }
23624         if (flags & NDR_OUT) {
23625                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
23626                 ndr->depth++;
23627                 ndr_print_ptr(ndr, "count", r->out.count);
23628                 ndr->depth++;
23629                 ndr_print_uint32(ndr, "count", *r->out.count);
23630                 ndr->depth--;
23631                 ndr_print_ptr(ndr, "info", r->out.info);
23632                 ndr->depth++;
23633                 ndr_print_ptr(ndr, "info", *r->out.info);
23634                 ndr->depth++;
23635                 if (*r->out.info) {
23636                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23637                         ndr->depth++;
23638                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23639                                 char *idx_2=NULL;
23640                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23641                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23642                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23643                                         free(idx_2);
23644                                 }
23645                         }
23646                         ndr->depth--;
23647                 }
23648                 ndr->depth--;
23649                 ndr->depth--;
23650                 ndr_print_ptr(ndr, "needed", r->out.needed);
23651                 ndr->depth++;
23652                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23653                 ndr->depth--;
23654                 ndr_print_WERROR(ndr, "result", r->out.result);
23655                 ndr->depth--;
23656         }
23657         ndr->depth--;
23658 }
23659
23660 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
23661 {
23662         if (flags & NDR_IN) {
23663                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23664                 if (r->in.servername) {
23665                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23666                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23667                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23668                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23669                 }
23670                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23671                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23672                 if (r->in.buffer) {
23673                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23674                 }
23675                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23676         }
23677         if (flags & NDR_OUT) {
23678                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23679                 if (r->out.info) {
23680                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23681                 }
23682                 if (r->out.needed == NULL) {
23683                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23684                 }
23685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23686                 if (r->out.count == NULL) {
23687                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23688                 }
23689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23690                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23691         }
23692         return NDR_ERR_SUCCESS;
23693 }
23694
23695 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
23696 {
23697         uint32_t _ptr_servername;
23698         uint32_t _ptr_buffer;
23699         uint32_t _ptr_info;
23700         TALLOC_CTX *_mem_save_servername_0;
23701         TALLOC_CTX *_mem_save_buffer_0;
23702         TALLOC_CTX *_mem_save_info_0;
23703         TALLOC_CTX *_mem_save_needed_0;
23704         TALLOC_CTX *_mem_save_count_0;
23705         if (flags & NDR_IN) {
23706                 ZERO_STRUCT(r->out);
23707
23708                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23709                 if (_ptr_servername) {
23710                         NDR_PULL_ALLOC(ndr, r->in.servername);
23711                 } else {
23712                         r->in.servername = NULL;
23713                 }
23714                 if (r->in.servername) {
23715                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23716                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23717                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23718                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23719                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23720                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
23721                         }
23722                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23723                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23724                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23725                 }
23726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23727                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23728                 if (_ptr_buffer) {
23729                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23730                 } else {
23731                         r->in.buffer = NULL;
23732                 }
23733                 if (r->in.buffer) {
23734                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23735                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23736                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23737                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23738                 }
23739                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23740                 NDR_PULL_ALLOC(ndr, r->out.needed);
23741                 ZERO_STRUCTP(r->out.needed);
23742                 NDR_PULL_ALLOC(ndr, r->out.count);
23743                 ZERO_STRUCTP(r->out.count);
23744         }
23745         if (flags & NDR_OUT) {
23746                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23747                 if (_ptr_info) {
23748                         NDR_PULL_ALLOC(ndr, r->out.info);
23749                 } else {
23750                         r->out.info = NULL;
23751                 }
23752                 if (r->out.info) {
23753                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23754                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23755                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23756                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23757                 }
23758                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23759                         NDR_PULL_ALLOC(ndr, r->out.needed);
23760                 }
23761                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23762                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23764                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23765                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23766                         NDR_PULL_ALLOC(ndr, r->out.count);
23767                 }
23768                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23769                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23771                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23772                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23773         }
23774         return NDR_ERR_SUCCESS;
23775 }
23776
23777 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
23778 {
23779         uint32_t cntr_info_0;
23780         if (flags & NDR_IN) {
23781                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23782                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23783         }
23784         if (flags & NDR_OUT) {
23785                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23786                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23787                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23788                 }
23789                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23790                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23791                 }
23792         }
23793         return NDR_ERR_SUCCESS;
23794 }
23795
23796 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
23797 {
23798         uint32_t cntr_info_0;
23799         TALLOC_CTX *_mem_save_info_0;
23800         if (flags & NDR_IN) {
23801                 ZERO_STRUCT(r->out);
23802
23803                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23804                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23805         }
23806         if (flags & NDR_OUT) {
23807                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23808                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23809                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23810                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23811                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23812                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23813                 }
23814                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23815                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23816                 }
23817                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23818         }
23819         return NDR_ERR_SUCCESS;
23820 }
23821
23822 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
23823 {
23824         uint32_t cntr_info_2;
23825         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
23826         ndr->depth++;
23827         if (flags & NDR_SET_VALUES) {
23828                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23829         }
23830         if (flags & NDR_IN) {
23831                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
23832                 ndr->depth++;
23833                 ndr_print_ptr(ndr, "servername", r->in.servername);
23834                 ndr->depth++;
23835                 if (r->in.servername) {
23836                         ndr_print_string(ndr, "servername", r->in.servername);
23837                 }
23838                 ndr->depth--;
23839                 ndr_print_uint32(ndr, "level", r->in.level);
23840                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23841                 ndr->depth++;
23842                 if (r->in.buffer) {
23843                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23844                 }
23845                 ndr->depth--;
23846                 ndr_print_uint32(ndr, "offered", r->in.offered);
23847                 ndr->depth--;
23848         }
23849         if (flags & NDR_OUT) {
23850                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
23851                 ndr->depth++;
23852                 ndr_print_ptr(ndr, "count", r->out.count);
23853                 ndr->depth++;
23854                 ndr_print_uint32(ndr, "count", *r->out.count);
23855                 ndr->depth--;
23856                 ndr_print_ptr(ndr, "info", r->out.info);
23857                 ndr->depth++;
23858                 ndr_print_ptr(ndr, "info", *r->out.info);
23859                 ndr->depth++;
23860                 if (*r->out.info) {
23861                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23862                         ndr->depth++;
23863                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23864                                 char *idx_2=NULL;
23865                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23866                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23867                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23868                                         free(idx_2);
23869                                 }
23870                         }
23871                         ndr->depth--;
23872                 }
23873                 ndr->depth--;
23874                 ndr->depth--;
23875                 ndr_print_ptr(ndr, "needed", r->out.needed);
23876                 ndr->depth++;
23877                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23878                 ndr->depth--;
23879                 ndr_print_WERROR(ndr, "result", r->out.result);
23880                 ndr->depth--;
23881         }
23882         ndr->depth--;
23883 }
23884
23885 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
23886 {
23887         if (flags & NDR_IN) {
23888                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
23889                 if (r->in.server_name) {
23890                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
23891                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23892                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
23893                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23894                 }
23895                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
23896                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
23897                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23898                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
23899                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.monitor_name, ndr_charset_length(r->in.monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23900         }
23901         if (flags & NDR_OUT) {
23902                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23903         }
23904         return NDR_ERR_SUCCESS;
23905 }
23906
23907 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
23908 {
23909         uint32_t _ptr_server_name;
23910         TALLOC_CTX *_mem_save_server_name_0;
23911         if (flags & NDR_IN) {
23912                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
23913                 if (_ptr_server_name) {
23914                         NDR_PULL_ALLOC(ndr, r->in.server_name);
23915                 } else {
23916                         r->in.server_name = NULL;
23917                 }
23918                 if (r->in.server_name) {
23919                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
23920                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
23921                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
23922                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
23923                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
23924                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server_name), ndr_get_array_length(ndr, &r->in.server_name));
23925                         }
23926                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
23927                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
23928                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
23929                 }
23930                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
23931                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
23932                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
23933                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
23934                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.monitor_name), ndr_get_array_length(ndr, &r->in.monitor_name));
23935                 }
23936                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
23937                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.monitor_name, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t), CH_UTF16));
23938         }
23939         if (flags & NDR_OUT) {
23940                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23941         }
23942         return NDR_ERR_SUCCESS;
23943 }
23944
23945 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
23946 {
23947         ndr_print_struct(ndr, name, "spoolss_AddPort");
23948         ndr->depth++;
23949         if (flags & NDR_SET_VALUES) {
23950                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23951         }
23952         if (flags & NDR_IN) {
23953                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
23954                 ndr->depth++;
23955                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
23956                 ndr->depth++;
23957                 if (r->in.server_name) {
23958                         ndr_print_string(ndr, "server_name", r->in.server_name);
23959                 }
23960                 ndr->depth--;
23961                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
23962                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
23963                 ndr->depth--;
23964         }
23965         if (flags & NDR_OUT) {
23966                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
23967                 ndr->depth++;
23968                 ndr_print_WERROR(ndr, "result", r->out.result);
23969                 ndr->depth--;
23970         }
23971         ndr->depth--;
23972 }
23973
23974 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
23975 {
23976         if (flags & NDR_IN) {
23977         }
23978         if (flags & NDR_OUT) {
23979                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23980         }
23981         return NDR_ERR_SUCCESS;
23982 }
23983
23984 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
23985 {
23986         if (flags & NDR_IN) {
23987         }
23988         if (flags & NDR_OUT) {
23989                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23990         }
23991         return NDR_ERR_SUCCESS;
23992 }
23993
23994 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
23995 {
23996         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
23997         ndr->depth++;
23998         if (flags & NDR_SET_VALUES) {
23999                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24000         }
24001         if (flags & NDR_IN) {
24002                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
24003                 ndr->depth++;
24004                 ndr->depth--;
24005         }
24006         if (flags & NDR_OUT) {
24007                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
24008                 ndr->depth++;
24009                 ndr_print_WERROR(ndr, "result", r->out.result);
24010                 ndr->depth--;
24011         }
24012         ndr->depth--;
24013 }
24014
24015 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
24016 {
24017         if (flags & NDR_IN) {
24018         }
24019         if (flags & NDR_OUT) {
24020                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24021         }
24022         return NDR_ERR_SUCCESS;
24023 }
24024
24025 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
24026 {
24027         if (flags & NDR_IN) {
24028         }
24029         if (flags & NDR_OUT) {
24030                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24031         }
24032         return NDR_ERR_SUCCESS;
24033 }
24034
24035 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
24036 {
24037         ndr_print_struct(ndr, name, "spoolss_DeletePort");
24038         ndr->depth++;
24039         if (flags & NDR_SET_VALUES) {
24040                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24041         }
24042         if (flags & NDR_IN) {
24043                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
24044                 ndr->depth++;
24045                 ndr->depth--;
24046         }
24047         if (flags & NDR_OUT) {
24048                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
24049                 ndr->depth++;
24050                 ndr_print_WERROR(ndr, "result", r->out.result);
24051                 ndr->depth--;
24052         }
24053         ndr->depth--;
24054 }
24055
24056 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
24057 {
24058         if (flags & NDR_IN) {
24059         }
24060         if (flags & NDR_OUT) {
24061                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24062         }
24063         return NDR_ERR_SUCCESS;
24064 }
24065
24066 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
24067 {
24068         if (flags & NDR_IN) {
24069         }
24070         if (flags & NDR_OUT) {
24071                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24072         }
24073         return NDR_ERR_SUCCESS;
24074 }
24075
24076 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
24077 {
24078         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
24079         ndr->depth++;
24080         if (flags & NDR_SET_VALUES) {
24081                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24082         }
24083         if (flags & NDR_IN) {
24084                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
24085                 ndr->depth++;
24086                 ndr->depth--;
24087         }
24088         if (flags & NDR_OUT) {
24089                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
24090                 ndr->depth++;
24091                 ndr_print_WERROR(ndr, "result", r->out.result);
24092                 ndr->depth--;
24093         }
24094         ndr->depth--;
24095 }
24096
24097 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
24098 {
24099         if (flags & NDR_IN) {
24100         }
24101         if (flags & NDR_OUT) {
24102                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24103         }
24104         return NDR_ERR_SUCCESS;
24105 }
24106
24107 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
24108 {
24109         if (flags & NDR_IN) {
24110         }
24111         if (flags & NDR_OUT) {
24112                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24113         }
24114         return NDR_ERR_SUCCESS;
24115 }
24116
24117 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
24118 {
24119         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
24120         ndr->depth++;
24121         if (flags & NDR_SET_VALUES) {
24122                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24123         }
24124         if (flags & NDR_IN) {
24125                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
24126                 ndr->depth++;
24127                 ndr->depth--;
24128         }
24129         if (flags & NDR_OUT) {
24130                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
24131                 ndr->depth++;
24132                 ndr_print_WERROR(ndr, "result", r->out.result);
24133                 ndr->depth--;
24134         }
24135         ndr->depth--;
24136 }
24137
24138 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
24139 {
24140         if (flags & NDR_IN) {
24141         }
24142         if (flags & NDR_OUT) {
24143                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24144         }
24145         return NDR_ERR_SUCCESS;
24146 }
24147
24148 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
24149 {
24150         if (flags & NDR_IN) {
24151         }
24152         if (flags & NDR_OUT) {
24153                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24154         }
24155         return NDR_ERR_SUCCESS;
24156 }
24157
24158 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
24159 {
24160         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
24161         ndr->depth++;
24162         if (flags & NDR_SET_VALUES) {
24163                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24164         }
24165         if (flags & NDR_IN) {
24166                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
24167                 ndr->depth++;
24168                 ndr->depth--;
24169         }
24170         if (flags & NDR_OUT) {
24171                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
24172                 ndr->depth++;
24173                 ndr_print_WERROR(ndr, "result", r->out.result);
24174                 ndr->depth--;
24175         }
24176         ndr->depth--;
24177 }
24178
24179 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
24180 {
24181         if (flags & NDR_IN) {
24182         }
24183         if (flags & NDR_OUT) {
24184                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24185         }
24186         return NDR_ERR_SUCCESS;
24187 }
24188
24189 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
24190 {
24191         if (flags & NDR_IN) {
24192         }
24193         if (flags & NDR_OUT) {
24194                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24195         }
24196         return NDR_ERR_SUCCESS;
24197 }
24198
24199 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
24200 {
24201         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
24202         ndr->depth++;
24203         if (flags & NDR_SET_VALUES) {
24204                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24205         }
24206         if (flags & NDR_IN) {
24207                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
24208                 ndr->depth++;
24209                 ndr->depth--;
24210         }
24211         if (flags & NDR_OUT) {
24212                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
24213                 ndr->depth++;
24214                 ndr_print_WERROR(ndr, "result", r->out.result);
24215                 ndr->depth--;
24216         }
24217         ndr->depth--;
24218 }
24219
24220 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
24221 {
24222         if (flags & NDR_IN) {
24223         }
24224         if (flags & NDR_OUT) {
24225                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24226         }
24227         return NDR_ERR_SUCCESS;
24228 }
24229
24230 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
24231 {
24232         if (flags & NDR_IN) {
24233         }
24234         if (flags & NDR_OUT) {
24235                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24236         }
24237         return NDR_ERR_SUCCESS;
24238 }
24239
24240 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
24241 {
24242         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
24243         ndr->depth++;
24244         if (flags & NDR_SET_VALUES) {
24245                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24246         }
24247         if (flags & NDR_IN) {
24248                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
24249                 ndr->depth++;
24250                 ndr->depth--;
24251         }
24252         if (flags & NDR_OUT) {
24253                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
24254                 ndr->depth++;
24255                 ndr_print_WERROR(ndr, "result", r->out.result);
24256                 ndr->depth--;
24257         }
24258         ndr->depth--;
24259 }
24260
24261 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
24262 {
24263         if (flags & NDR_IN) {
24264         }
24265         if (flags & NDR_OUT) {
24266                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24267         }
24268         return NDR_ERR_SUCCESS;
24269 }
24270
24271 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
24272 {
24273         if (flags & NDR_IN) {
24274         }
24275         if (flags & NDR_OUT) {
24276                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24277         }
24278         return NDR_ERR_SUCCESS;
24279 }
24280
24281 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
24282 {
24283         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
24284         ndr->depth++;
24285         if (flags & NDR_SET_VALUES) {
24286                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24287         }
24288         if (flags & NDR_IN) {
24289                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
24290                 ndr->depth++;
24291                 ndr->depth--;
24292         }
24293         if (flags & NDR_OUT) {
24294                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
24295                 ndr->depth++;
24296                 ndr_print_WERROR(ndr, "result", r->out.result);
24297                 ndr->depth--;
24298         }
24299         ndr->depth--;
24300 }
24301
24302 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
24303 {
24304         if (flags & NDR_IN) {
24305         }
24306         if (flags & NDR_OUT) {
24307                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24308         }
24309         return NDR_ERR_SUCCESS;
24310 }
24311
24312 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
24313 {
24314         if (flags & NDR_IN) {
24315         }
24316         if (flags & NDR_OUT) {
24317                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24318         }
24319         return NDR_ERR_SUCCESS;
24320 }
24321
24322 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
24323 {
24324         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
24325         ndr->depth++;
24326         if (flags & NDR_SET_VALUES) {
24327                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24328         }
24329         if (flags & NDR_IN) {
24330                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
24331                 ndr->depth++;
24332                 ndr->depth--;
24333         }
24334         if (flags & NDR_OUT) {
24335                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
24336                 ndr->depth++;
24337                 ndr_print_WERROR(ndr, "result", r->out.result);
24338                 ndr->depth--;
24339         }
24340         ndr->depth--;
24341 }
24342
24343 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
24344 {
24345         if (flags & NDR_IN) {
24346         }
24347         if (flags & NDR_OUT) {
24348                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24349         }
24350         return NDR_ERR_SUCCESS;
24351 }
24352
24353 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
24354 {
24355         if (flags & NDR_IN) {
24356         }
24357         if (flags & NDR_OUT) {
24358                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24359         }
24360         return NDR_ERR_SUCCESS;
24361 }
24362
24363 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
24364 {
24365         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
24366         ndr->depth++;
24367         if (flags & NDR_SET_VALUES) {
24368                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24369         }
24370         if (flags & NDR_IN) {
24371                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
24372                 ndr->depth++;
24373                 ndr->depth--;
24374         }
24375         if (flags & NDR_OUT) {
24376                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
24377                 ndr->depth++;
24378                 ndr_print_WERROR(ndr, "result", r->out.result);
24379                 ndr->depth--;
24380         }
24381         ndr->depth--;
24382 }
24383
24384 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
24385 {
24386         if (flags & NDR_IN) {
24387         }
24388         if (flags & NDR_OUT) {
24389                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24390         }
24391         return NDR_ERR_SUCCESS;
24392 }
24393
24394 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
24395 {
24396         if (flags & NDR_IN) {
24397         }
24398         if (flags & NDR_OUT) {
24399                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24400         }
24401         return NDR_ERR_SUCCESS;
24402 }
24403
24404 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
24405 {
24406         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
24407         ndr->depth++;
24408         if (flags & NDR_SET_VALUES) {
24409                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24410         }
24411         if (flags & NDR_IN) {
24412                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
24413                 ndr->depth++;
24414                 ndr->depth--;
24415         }
24416         if (flags & NDR_OUT) {
24417                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
24418                 ndr->depth++;
24419                 ndr_print_WERROR(ndr, "result", r->out.result);
24420                 ndr->depth--;
24421         }
24422         ndr->depth--;
24423 }
24424
24425 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
24426 {
24427         if (flags & NDR_IN) {
24428         }
24429         if (flags & NDR_OUT) {
24430                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24431         }
24432         return NDR_ERR_SUCCESS;
24433 }
24434
24435 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
24436 {
24437         if (flags & NDR_IN) {
24438         }
24439         if (flags & NDR_OUT) {
24440                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24441         }
24442         return NDR_ERR_SUCCESS;
24443 }
24444
24445 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
24446 {
24447         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
24448         ndr->depth++;
24449         if (flags & NDR_SET_VALUES) {
24450                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24451         }
24452         if (flags & NDR_IN) {
24453                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
24454                 ndr->depth++;
24455                 ndr->depth--;
24456         }
24457         if (flags & NDR_OUT) {
24458                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
24459                 ndr->depth++;
24460                 ndr_print_WERROR(ndr, "result", r->out.result);
24461                 ndr->depth--;
24462         }
24463         ndr->depth--;
24464 }
24465
24466 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
24467 {
24468         if (flags & NDR_IN) {
24469         }
24470         if (flags & NDR_OUT) {
24471                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24472         }
24473         return NDR_ERR_SUCCESS;
24474 }
24475
24476 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
24477 {
24478         if (flags & NDR_IN) {
24479         }
24480         if (flags & NDR_OUT) {
24481                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24482         }
24483         return NDR_ERR_SUCCESS;
24484 }
24485
24486 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
24487 {
24488         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
24489         ndr->depth++;
24490         if (flags & NDR_SET_VALUES) {
24491                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24492         }
24493         if (flags & NDR_IN) {
24494                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
24495                 ndr->depth++;
24496                 ndr->depth--;
24497         }
24498         if (flags & NDR_OUT) {
24499                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
24500                 ndr->depth++;
24501                 ndr_print_WERROR(ndr, "result", r->out.result);
24502                 ndr->depth--;
24503         }
24504         ndr->depth--;
24505 }
24506
24507 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
24508 {
24509         if (flags & NDR_IN) {
24510                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24511                 if (r->in.servername) {
24512                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24513                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24514                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24515                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24516                 }
24517                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
24518                 if (r->in.print_processor_name) {
24519                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
24520                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24521                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
24522                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.print_processor_name, ndr_charset_length(r->in.print_processor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24523                 }
24524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24525                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24526                 if (r->in.buffer) {
24527                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24528                 }
24529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24530         }
24531         if (flags & NDR_OUT) {
24532                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24533                 if (r->out.info) {
24534                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24535                 }
24536                 if (r->out.needed == NULL) {
24537                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24538                 }
24539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24540                 if (r->out.count == NULL) {
24541                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24542                 }
24543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24544                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24545         }
24546         return NDR_ERR_SUCCESS;
24547 }
24548
24549 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
24550 {
24551         uint32_t _ptr_servername;
24552         uint32_t _ptr_print_processor_name;
24553         uint32_t _ptr_buffer;
24554         uint32_t _ptr_info;
24555         TALLOC_CTX *_mem_save_servername_0;
24556         TALLOC_CTX *_mem_save_print_processor_name_0;
24557         TALLOC_CTX *_mem_save_buffer_0;
24558         TALLOC_CTX *_mem_save_info_0;
24559         TALLOC_CTX *_mem_save_needed_0;
24560         TALLOC_CTX *_mem_save_count_0;
24561         if (flags & NDR_IN) {
24562                 ZERO_STRUCT(r->out);
24563
24564                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24565                 if (_ptr_servername) {
24566                         NDR_PULL_ALLOC(ndr, r->in.servername);
24567                 } else {
24568                         r->in.servername = NULL;
24569                 }
24570                 if (r->in.servername) {
24571                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24572                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24573                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24574                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24575                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24576                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
24577                         }
24578                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24579                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24580                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24581                 }
24582                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
24583                 if (_ptr_print_processor_name) {
24584                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
24585                 } else {
24586                         r->in.print_processor_name = NULL;
24587                 }
24588                 if (r->in.print_processor_name) {
24589                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
24590                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
24591                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
24592                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
24593                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
24594                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.print_processor_name), ndr_get_array_length(ndr, &r->in.print_processor_name));
24595                         }
24596                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
24597                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.print_processor_name, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t), CH_UTF16));
24598                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
24599                 }
24600                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24601                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24602                 if (_ptr_buffer) {
24603                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24604                 } else {
24605                         r->in.buffer = NULL;
24606                 }
24607                 if (r->in.buffer) {
24608                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24609                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24610                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24611                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24612                 }
24613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24614                 NDR_PULL_ALLOC(ndr, r->out.needed);
24615                 ZERO_STRUCTP(r->out.needed);
24616                 NDR_PULL_ALLOC(ndr, r->out.count);
24617                 ZERO_STRUCTP(r->out.count);
24618         }
24619         if (flags & NDR_OUT) {
24620                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24621                 if (_ptr_info) {
24622                         NDR_PULL_ALLOC(ndr, r->out.info);
24623                 } else {
24624                         r->out.info = NULL;
24625                 }
24626                 if (r->out.info) {
24627                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24628                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24629                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24630                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24631                 }
24632                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24633                         NDR_PULL_ALLOC(ndr, r->out.needed);
24634                 }
24635                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24636                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24637                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24638                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24639                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24640                         NDR_PULL_ALLOC(ndr, r->out.count);
24641                 }
24642                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24643                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24644                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24645                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24646                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24647         }
24648         return NDR_ERR_SUCCESS;
24649 }
24650
24651 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
24652 {
24653         uint32_t cntr_info_0;
24654         if (flags & NDR_IN) {
24655                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24656                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24657         }
24658         if (flags & NDR_OUT) {
24659                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24660                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24661                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24662                 }
24663                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24664                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24665                 }
24666         }
24667         return NDR_ERR_SUCCESS;
24668 }
24669
24670 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
24671 {
24672         uint32_t cntr_info_0;
24673         TALLOC_CTX *_mem_save_info_0;
24674         if (flags & NDR_IN) {
24675                 ZERO_STRUCT(r->out);
24676
24677                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24678                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24679         }
24680         if (flags & NDR_OUT) {
24681                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24682                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24683                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24684                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24685                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24686                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24687                 }
24688                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24689                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24690                 }
24691                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24692         }
24693         return NDR_ERR_SUCCESS;
24694 }
24695
24696 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
24697 {
24698         uint32_t cntr_info_2;
24699         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
24700         ndr->depth++;
24701         if (flags & NDR_SET_VALUES) {
24702                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24703         }
24704         if (flags & NDR_IN) {
24705                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
24706                 ndr->depth++;
24707                 ndr_print_ptr(ndr, "servername", r->in.servername);
24708                 ndr->depth++;
24709                 if (r->in.servername) {
24710                         ndr_print_string(ndr, "servername", r->in.servername);
24711                 }
24712                 ndr->depth--;
24713                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
24714                 ndr->depth++;
24715                 if (r->in.print_processor_name) {
24716                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
24717                 }
24718                 ndr->depth--;
24719                 ndr_print_uint32(ndr, "level", r->in.level);
24720                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24721                 ndr->depth++;
24722                 if (r->in.buffer) {
24723                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24724                 }
24725                 ndr->depth--;
24726                 ndr_print_uint32(ndr, "offered", r->in.offered);
24727                 ndr->depth--;
24728         }
24729         if (flags & NDR_OUT) {
24730                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
24731                 ndr->depth++;
24732                 ndr_print_ptr(ndr, "count", r->out.count);
24733                 ndr->depth++;
24734                 ndr_print_uint32(ndr, "count", *r->out.count);
24735                 ndr->depth--;
24736                 ndr_print_ptr(ndr, "info", r->out.info);
24737                 ndr->depth++;
24738                 ndr_print_ptr(ndr, "info", *r->out.info);
24739                 ndr->depth++;
24740                 if (*r->out.info) {
24741                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24742                         ndr->depth++;
24743                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24744                                 char *idx_2=NULL;
24745                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24746                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24747                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24748                                         free(idx_2);
24749                                 }
24750                         }
24751                         ndr->depth--;
24752                 }
24753                 ndr->depth--;
24754                 ndr->depth--;
24755                 ndr_print_ptr(ndr, "needed", r->out.needed);
24756                 ndr->depth++;
24757                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24758                 ndr->depth--;
24759                 ndr_print_WERROR(ndr, "result", r->out.result);
24760                 ndr->depth--;
24761         }
24762         ndr->depth--;
24763 }
24764
24765 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
24766 {
24767         if (flags & NDR_IN) {
24768                 if (r->in.handle == NULL) {
24769                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24770                 }
24771                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24772                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
24773                 if (r->in.data_type) {
24774                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
24775                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24776                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
24777                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.data_type, ndr_charset_length(r->in.data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24778                 }
24779                 if (r->in.devmode_ctr == NULL) {
24780                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24781                 }
24782                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24783         }
24784         if (flags & NDR_OUT) {
24785                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24786         }
24787         return NDR_ERR_SUCCESS;
24788 }
24789
24790 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
24791 {
24792         uint32_t _ptr_data_type;
24793         TALLOC_CTX *_mem_save_handle_0;
24794         TALLOC_CTX *_mem_save_data_type_0;
24795         TALLOC_CTX *_mem_save_devmode_ctr_0;
24796         if (flags & NDR_IN) {
24797                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24798                         NDR_PULL_ALLOC(ndr, r->in.handle);
24799                 }
24800                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24801                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24802                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24803                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24804                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
24805                 if (_ptr_data_type) {
24806                         NDR_PULL_ALLOC(ndr, r->in.data_type);
24807                 } else {
24808                         r->in.data_type = NULL;
24809                 }
24810                 if (r->in.data_type) {
24811                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
24812                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
24813                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
24814                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
24815                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
24816                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.data_type), ndr_get_array_length(ndr, &r->in.data_type));
24817                         }
24818                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
24819                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.data_type, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t), CH_UTF16));
24820                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
24821                 }
24822                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24823                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
24824                 }
24825                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
24826                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
24827                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24828                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
24829         }
24830         if (flags & NDR_OUT) {
24831                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24832         }
24833         return NDR_ERR_SUCCESS;
24834 }
24835
24836 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
24837 {
24838         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
24839         ndr->depth++;
24840         if (flags & NDR_SET_VALUES) {
24841                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24842         }
24843         if (flags & NDR_IN) {
24844                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
24845                 ndr->depth++;
24846                 ndr_print_ptr(ndr, "handle", r->in.handle);
24847                 ndr->depth++;
24848                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24849                 ndr->depth--;
24850                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
24851                 ndr->depth++;
24852                 if (r->in.data_type) {
24853                         ndr_print_string(ndr, "data_type", r->in.data_type);
24854                 }
24855                 ndr->depth--;
24856                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
24857                 ndr->depth++;
24858                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
24859                 ndr->depth--;
24860                 ndr->depth--;
24861         }
24862         if (flags & NDR_OUT) {
24863                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
24864                 ndr->depth++;
24865                 ndr_print_WERROR(ndr, "result", r->out.result);
24866                 ndr->depth--;
24867         }
24868         ndr->depth--;
24869 }
24870
24871 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
24872 {
24873         if (flags & NDR_IN) {
24874                 if (r->in.handle == NULL) {
24875                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24876                 }
24877                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24878                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
24879                 if (r->in.architecture) {
24880                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
24881                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24882                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
24883                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24884                 }
24885                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24886                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24887                 if (r->in.buffer) {
24888                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24889                 }
24890                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24891                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
24892                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
24893         }
24894         if (flags & NDR_OUT) {
24895                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24896                 if (r->out.info) {
24897                         {
24898                                 struct ndr_push *_ndr_info;
24899                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24900                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
24901                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24902                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24903                         }
24904                 }
24905                 if (r->out.needed == NULL) {
24906                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24907                 }
24908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24909                 if (r->out.server_major_version == NULL) {
24910                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24911                 }
24912                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
24913                 if (r->out.server_minor_version == NULL) {
24914                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24915                 }
24916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
24917                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24918         }
24919         return NDR_ERR_SUCCESS;
24920 }
24921
24922 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
24923 {
24924         uint32_t _ptr_architecture;
24925         uint32_t _ptr_buffer;
24926         uint32_t _ptr_info;
24927         TALLOC_CTX *_mem_save_handle_0;
24928         TALLOC_CTX *_mem_save_architecture_0;
24929         TALLOC_CTX *_mem_save_buffer_0;
24930         TALLOC_CTX *_mem_save_info_0;
24931         TALLOC_CTX *_mem_save_needed_0;
24932         TALLOC_CTX *_mem_save_server_major_version_0;
24933         TALLOC_CTX *_mem_save_server_minor_version_0;
24934         if (flags & NDR_IN) {
24935                 ZERO_STRUCT(r->out);
24936
24937                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24938                         NDR_PULL_ALLOC(ndr, r->in.handle);
24939                 }
24940                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24941                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24942                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24943                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24944                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
24945                 if (_ptr_architecture) {
24946                         NDR_PULL_ALLOC(ndr, r->in.architecture);
24947                 } else {
24948                         r->in.architecture = NULL;
24949                 }
24950                 if (r->in.architecture) {
24951                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
24952                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
24953                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
24954                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
24955                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
24956                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture));
24957                         }
24958                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
24959                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
24960                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
24961                 }
24962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24963                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24964                 if (_ptr_buffer) {
24965                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24966                 } else {
24967                         r->in.buffer = NULL;
24968                 }
24969                 if (r->in.buffer) {
24970                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24971                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24972                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24973                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24974                 }
24975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24976                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
24977                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
24978                 NDR_PULL_ALLOC(ndr, r->out.needed);
24979                 ZERO_STRUCTP(r->out.needed);
24980                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24981                 ZERO_STRUCTP(r->out.server_major_version);
24982                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24983                 ZERO_STRUCTP(r->out.server_minor_version);
24984         }
24985         if (flags & NDR_OUT) {
24986                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24987                 if (_ptr_info) {
24988                         NDR_PULL_ALLOC(ndr, r->out.info);
24989                 } else {
24990                         r->out.info = NULL;
24991                 }
24992                 if (r->out.info) {
24993                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24994                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24995                         {
24996                                 struct ndr_pull *_ndr_info;
24997                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24998                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24999                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
25000                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
25001                         }
25002                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25003                 }
25004                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25005                         NDR_PULL_ALLOC(ndr, r->out.needed);
25006                 }
25007                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25008                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25009                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25010                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25011                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25012                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
25013                 }
25014                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
25015                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
25016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
25017                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
25018                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25019                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
25020                 }
25021                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
25022                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
25023                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
25024                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
25025                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25026         }
25027         return NDR_ERR_SUCCESS;
25028 }
25029
25030 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
25031 {
25032         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
25033         ndr->depth++;
25034         if (flags & NDR_SET_VALUES) {
25035                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25036         }
25037         if (flags & NDR_IN) {
25038                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
25039                 ndr->depth++;
25040                 ndr_print_ptr(ndr, "handle", r->in.handle);
25041                 ndr->depth++;
25042                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25043                 ndr->depth--;
25044                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
25045                 ndr->depth++;
25046                 if (r->in.architecture) {
25047                         ndr_print_string(ndr, "architecture", r->in.architecture);
25048                 }
25049                 ndr->depth--;
25050                 ndr_print_uint32(ndr, "level", r->in.level);
25051                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25052                 ndr->depth++;
25053                 if (r->in.buffer) {
25054                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25055                 }
25056                 ndr->depth--;
25057                 ndr_print_uint32(ndr, "offered", r->in.offered);
25058                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
25059                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
25060                 ndr->depth--;
25061         }
25062         if (flags & NDR_OUT) {
25063                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
25064                 ndr->depth++;
25065                 ndr_print_ptr(ndr, "info", r->out.info);
25066                 ndr->depth++;
25067                 if (r->out.info) {
25068                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
25069                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
25070                 }
25071                 ndr->depth--;
25072                 ndr_print_ptr(ndr, "needed", r->out.needed);
25073                 ndr->depth++;
25074                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25075                 ndr->depth--;
25076                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
25077                 ndr->depth++;
25078                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
25079                 ndr->depth--;
25080                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
25081                 ndr->depth++;
25082                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
25083                 ndr->depth--;
25084                 ndr_print_WERROR(ndr, "result", r->out.result);
25085                 ndr->depth--;
25086         }
25087         ndr->depth--;
25088 }
25089
25090 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
25091 {
25092         if (flags & NDR_IN) {
25093         }
25094         if (flags & NDR_OUT) {
25095                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25096         }
25097         return NDR_ERR_SUCCESS;
25098 }
25099
25100 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
25101 {
25102         if (flags & NDR_IN) {
25103         }
25104         if (flags & NDR_OUT) {
25105                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25106         }
25107         return NDR_ERR_SUCCESS;
25108 }
25109
25110 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
25111 {
25112         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
25113         ndr->depth++;
25114         if (flags & NDR_SET_VALUES) {
25115                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25116         }
25117         if (flags & NDR_IN) {
25118                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
25119                 ndr->depth++;
25120                 ndr->depth--;
25121         }
25122         if (flags & NDR_OUT) {
25123                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
25124                 ndr->depth++;
25125                 ndr_print_WERROR(ndr, "result", r->out.result);
25126                 ndr->depth--;
25127         }
25128         ndr->depth--;
25129 }
25130
25131 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
25132 {
25133         if (flags & NDR_IN) {
25134         }
25135         if (flags & NDR_OUT) {
25136                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25137         }
25138         return NDR_ERR_SUCCESS;
25139 }
25140
25141 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
25142 {
25143         if (flags & NDR_IN) {
25144         }
25145         if (flags & NDR_OUT) {
25146                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25147         }
25148         return NDR_ERR_SUCCESS;
25149 }
25150
25151 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
25152 {
25153         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
25154         ndr->depth++;
25155         if (flags & NDR_SET_VALUES) {
25156                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25157         }
25158         if (flags & NDR_IN) {
25159                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
25160                 ndr->depth++;
25161                 ndr->depth--;
25162         }
25163         if (flags & NDR_OUT) {
25164                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
25165                 ndr->depth++;
25166                 ndr_print_WERROR(ndr, "result", r->out.result);
25167                 ndr->depth--;
25168         }
25169         ndr->depth--;
25170 }
25171
25172 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
25173 {
25174         if (flags & NDR_IN) {
25175                 if (r->in.handle == NULL) {
25176                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25177                 }
25178                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25179         }
25180         if (flags & NDR_OUT) {
25181                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25182         }
25183         return NDR_ERR_SUCCESS;
25184 }
25185
25186 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
25187 {
25188         TALLOC_CTX *_mem_save_handle_0;
25189         if (flags & NDR_IN) {
25190                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25191                         NDR_PULL_ALLOC(ndr, r->in.handle);
25192                 }
25193                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25194                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25195                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25196                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25197         }
25198         if (flags & NDR_OUT) {
25199                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25200         }
25201         return NDR_ERR_SUCCESS;
25202 }
25203
25204 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
25205 {
25206         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
25207         ndr->depth++;
25208         if (flags & NDR_SET_VALUES) {
25209                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25210         }
25211         if (flags & NDR_IN) {
25212                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
25213                 ndr->depth++;
25214                 ndr_print_ptr(ndr, "handle", r->in.handle);
25215                 ndr->depth++;
25216                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25217                 ndr->depth--;
25218                 ndr->depth--;
25219         }
25220         if (flags & NDR_OUT) {
25221                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
25222                 ndr->depth++;
25223                 ndr_print_WERROR(ndr, "result", r->out.result);
25224                 ndr->depth--;
25225         }
25226         ndr->depth--;
25227 }
25228
25229 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
25230 {
25231         if (flags & NDR_IN) {
25232         }
25233         if (flags & NDR_OUT) {
25234                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25235         }
25236         return NDR_ERR_SUCCESS;
25237 }
25238
25239 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
25240 {
25241         if (flags & NDR_IN) {
25242         }
25243         if (flags & NDR_OUT) {
25244                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25245         }
25246         return NDR_ERR_SUCCESS;
25247 }
25248
25249 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
25250 {
25251         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
25252         ndr->depth++;
25253         if (flags & NDR_SET_VALUES) {
25254                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25255         }
25256         if (flags & NDR_IN) {
25257                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
25258                 ndr->depth++;
25259                 ndr->depth--;
25260         }
25261         if (flags & NDR_OUT) {
25262                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
25263                 ndr->depth++;
25264                 ndr_print_WERROR(ndr, "result", r->out.result);
25265                 ndr->depth--;
25266         }
25267         ndr->depth--;
25268 }
25269
25270 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
25271 {
25272         if (flags & NDR_IN) {
25273                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
25274                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25275                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
25276                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25277                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
25278                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
25279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
25280                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25281                 if (r->in.buffer) {
25282                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
25283                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
25284                 }
25285         }
25286         if (flags & NDR_OUT) {
25287                 if (r->out.handle == NULL) {
25288                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25289                 }
25290                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25291                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25292         }
25293         return NDR_ERR_SUCCESS;
25294 }
25295
25296 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
25297 {
25298         uint32_t _ptr_buffer;
25299         TALLOC_CTX *_mem_save_buffer_0;
25300         TALLOC_CTX *_mem_save_handle_0;
25301         if (flags & NDR_IN) {
25302                 ZERO_STRUCT(r->out);
25303
25304                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
25305                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
25306                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
25307                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server_name), ndr_get_array_length(ndr, &r->in.server_name));
25308                 }
25309                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
25310                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
25311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
25312                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
25313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
25314                 if (r->in.bufsize > 512) {
25315                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
25316                 }
25317                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25318                 if (_ptr_buffer) {
25319                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25320                 } else {
25321                         r->in.buffer = NULL;
25322                 }
25323                 if (r->in.buffer) {
25324                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25325                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25326                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
25327                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
25328                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
25329                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25330                 }
25331                 NDR_PULL_ALLOC(ndr, r->out.handle);
25332                 ZERO_STRUCTP(r->out.handle);
25333                 if (r->in.buffer) {
25334                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
25335                 }
25336         }
25337         if (flags & NDR_OUT) {
25338                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25339                         NDR_PULL_ALLOC(ndr, r->out.handle);
25340                 }
25341                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25342                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25343                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25344                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25345                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25346         }
25347         return NDR_ERR_SUCCESS;
25348 }
25349
25350 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
25351 {
25352         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
25353         ndr->depth++;
25354         if (flags & NDR_SET_VALUES) {
25355                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25356         }
25357         if (flags & NDR_IN) {
25358                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
25359                 ndr->depth++;
25360                 ndr_print_string(ndr, "server_name", r->in.server_name);
25361                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
25362                 ndr_print_winreg_Type(ndr, "type", r->in.type);
25363                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
25364                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25365                 ndr->depth++;
25366                 if (r->in.buffer) {
25367                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
25368                 }
25369                 ndr->depth--;
25370                 ndr->depth--;
25371         }
25372         if (flags & NDR_OUT) {
25373                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
25374                 ndr->depth++;
25375                 ndr_print_ptr(ndr, "handle", r->out.handle);
25376                 ndr->depth++;
25377                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25378                 ndr->depth--;
25379                 ndr_print_WERROR(ndr, "result", r->out.result);
25380                 ndr->depth--;
25381         }
25382         ndr->depth--;
25383 }
25384
25385 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
25386 {
25387         if (flags & NDR_IN) {
25388                 if (r->in.handle == NULL) {
25389                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25390                 }
25391                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25392                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
25393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
25394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25395                 if (r->in.buffer) {
25396                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
25397                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
25398                 }
25399         }
25400         if (flags & NDR_OUT) {
25401                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25402         }
25403         return NDR_ERR_SUCCESS;
25404 }
25405
25406 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
25407 {
25408         uint32_t _ptr_buffer;
25409         TALLOC_CTX *_mem_save_handle_0;
25410         TALLOC_CTX *_mem_save_buffer_0;
25411         if (flags & NDR_IN) {
25412                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25413                         NDR_PULL_ALLOC(ndr, r->in.handle);
25414                 }
25415                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25416                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25417                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25418                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25419                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
25420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
25421                 if (r->in.bufsize > 512) {
25422                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
25423                 }
25424                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25425                 if (_ptr_buffer) {
25426                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25427                 } else {
25428                         r->in.buffer = NULL;
25429                 }
25430                 if (r->in.buffer) {
25431                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25432                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25433                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
25434                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
25435                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
25436                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25437                 }
25438                 if (r->in.buffer) {
25439                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
25440                 }
25441         }
25442         if (flags & NDR_OUT) {
25443                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25444         }
25445         return NDR_ERR_SUCCESS;
25446 }
25447
25448 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
25449 {
25450         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
25451         ndr->depth++;
25452         if (flags & NDR_SET_VALUES) {
25453                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25454         }
25455         if (flags & NDR_IN) {
25456                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
25457                 ndr->depth++;
25458                 ndr_print_ptr(ndr, "handle", r->in.handle);
25459                 ndr->depth++;
25460                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25461                 ndr->depth--;
25462                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
25463                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
25464                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25465                 ndr->depth++;
25466                 if (r->in.buffer) {
25467                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
25468                 }
25469                 ndr->depth--;
25470                 ndr->depth--;
25471         }
25472         if (flags & NDR_OUT) {
25473                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
25474                 ndr->depth++;
25475                 ndr_print_WERROR(ndr, "result", r->out.result);
25476                 ndr->depth--;
25477         }
25478         ndr->depth--;
25479 }
25480
25481 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
25482 {
25483         if (flags & NDR_IN) {
25484                 if (r->in.handle == NULL) {
25485                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25486                 }
25487                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25488         }
25489         if (flags & NDR_OUT) {
25490                 if (r->out.handle == NULL) {
25491                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25492                 }
25493                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25494                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25495         }
25496         return NDR_ERR_SUCCESS;
25497 }
25498
25499 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
25500 {
25501         TALLOC_CTX *_mem_save_handle_0;
25502         if (flags & NDR_IN) {
25503                 ZERO_STRUCT(r->out);
25504
25505                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25506                         NDR_PULL_ALLOC(ndr, r->in.handle);
25507                 }
25508                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25509                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25510                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25511                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25512                 NDR_PULL_ALLOC(ndr, r->out.handle);
25513                 *r->out.handle = *r->in.handle;
25514         }
25515         if (flags & NDR_OUT) {
25516                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25517                         NDR_PULL_ALLOC(ndr, r->out.handle);
25518                 }
25519                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25520                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25521                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25522                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25523                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25524         }
25525         return NDR_ERR_SUCCESS;
25526 }
25527
25528 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
25529 {
25530         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
25531         ndr->depth++;
25532         if (flags & NDR_SET_VALUES) {
25533                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25534         }
25535         if (flags & NDR_IN) {
25536                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
25537                 ndr->depth++;
25538                 ndr_print_ptr(ndr, "handle", r->in.handle);
25539                 ndr->depth++;
25540                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25541                 ndr->depth--;
25542                 ndr->depth--;
25543         }
25544         if (flags & NDR_OUT) {
25545                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
25546                 ndr->depth++;
25547                 ndr_print_ptr(ndr, "handle", r->out.handle);
25548                 ndr->depth++;
25549                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25550                 ndr->depth--;
25551                 ndr_print_WERROR(ndr, "result", r->out.result);
25552                 ndr->depth--;
25553         }
25554         ndr->depth--;
25555 }
25556
25557 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
25558 {
25559         if (flags & NDR_IN) {
25560         }
25561         if (flags & NDR_OUT) {
25562                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25563         }
25564         return NDR_ERR_SUCCESS;
25565 }
25566
25567 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
25568 {
25569         if (flags & NDR_IN) {
25570         }
25571         if (flags & NDR_OUT) {
25572                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25573         }
25574         return NDR_ERR_SUCCESS;
25575 }
25576
25577 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
25578 {
25579         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
25580         ndr->depth++;
25581         if (flags & NDR_SET_VALUES) {
25582                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25583         }
25584         if (flags & NDR_IN) {
25585                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
25586                 ndr->depth++;
25587                 ndr->depth--;
25588         }
25589         if (flags & NDR_OUT) {
25590                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
25591                 ndr->depth++;
25592                 ndr_print_WERROR(ndr, "result", r->out.result);
25593                 ndr->depth--;
25594         }
25595         ndr->depth--;
25596 }
25597
25598 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
25599 {
25600         if (flags & NDR_IN) {
25601         }
25602         if (flags & NDR_OUT) {
25603                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25604         }
25605         return NDR_ERR_SUCCESS;
25606 }
25607
25608 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
25609 {
25610         if (flags & NDR_IN) {
25611         }
25612         if (flags & NDR_OUT) {
25613                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25614         }
25615         return NDR_ERR_SUCCESS;
25616 }
25617
25618 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
25619 {
25620         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
25621         ndr->depth++;
25622         if (flags & NDR_SET_VALUES) {
25623                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25624         }
25625         if (flags & NDR_IN) {
25626                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
25627                 ndr->depth++;
25628                 ndr->depth--;
25629         }
25630         if (flags & NDR_OUT) {
25631                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
25632                 ndr->depth++;
25633                 ndr_print_WERROR(ndr, "result", r->out.result);
25634                 ndr->depth--;
25635         }
25636         ndr->depth--;
25637 }
25638
25639 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
25640 {
25641         if (flags & NDR_IN) {
25642         }
25643         if (flags & NDR_OUT) {
25644                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25645         }
25646         return NDR_ERR_SUCCESS;
25647 }
25648
25649 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
25650 {
25651         if (flags & NDR_IN) {
25652         }
25653         if (flags & NDR_OUT) {
25654                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25655         }
25656         return NDR_ERR_SUCCESS;
25657 }
25658
25659 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
25660 {
25661         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
25662         ndr->depth++;
25663         if (flags & NDR_SET_VALUES) {
25664                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25665         }
25666         if (flags & NDR_IN) {
25667                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
25668                 ndr->depth++;
25669                 ndr->depth--;
25670         }
25671         if (flags & NDR_OUT) {
25672                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
25673                 ndr->depth++;
25674                 ndr_print_WERROR(ndr, "result", r->out.result);
25675                 ndr->depth--;
25676         }
25677         ndr->depth--;
25678 }
25679
25680 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
25681 {
25682         if (flags & NDR_IN) {
25683         }
25684         if (flags & NDR_OUT) {
25685                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25686         }
25687         return NDR_ERR_SUCCESS;
25688 }
25689
25690 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
25691 {
25692         if (flags & NDR_IN) {
25693         }
25694         if (flags & NDR_OUT) {
25695                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25696         }
25697         return NDR_ERR_SUCCESS;
25698 }
25699
25700 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
25701 {
25702         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
25703         ndr->depth++;
25704         if (flags & NDR_SET_VALUES) {
25705                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25706         }
25707         if (flags & NDR_IN) {
25708                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
25709                 ndr->depth++;
25710                 ndr->depth--;
25711         }
25712         if (flags & NDR_OUT) {
25713                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
25714                 ndr->depth++;
25715                 ndr_print_WERROR(ndr, "result", r->out.result);
25716                 ndr->depth--;
25717         }
25718         ndr->depth--;
25719 }
25720
25721 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
25722 {
25723         if (flags & NDR_IN) {
25724                 if (r->in.handle == NULL) {
25725                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25726                 }
25727                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25728                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
25729                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
25730                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
25731                 if (r->in.local_machine) {
25732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
25733                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25734                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
25735                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.local_machine, ndr_charset_length(r->in.local_machine, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25736                 }
25737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
25738                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
25739                 if (r->in.notify_options) {
25740                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
25741                 }
25742         }
25743         if (flags & NDR_OUT) {
25744                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25745         }
25746         return NDR_ERR_SUCCESS;
25747 }
25748
25749 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
25750 {
25751         uint32_t _ptr_local_machine;
25752         uint32_t _ptr_notify_options;
25753         TALLOC_CTX *_mem_save_handle_0;
25754         TALLOC_CTX *_mem_save_local_machine_0;
25755         TALLOC_CTX *_mem_save_notify_options_0;
25756         if (flags & NDR_IN) {
25757                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25758                         NDR_PULL_ALLOC(ndr, r->in.handle);
25759                 }
25760                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25761                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25762                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25763                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25764                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
25765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
25766                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
25767                 if (_ptr_local_machine) {
25768                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
25769                 } else {
25770                         r->in.local_machine = NULL;
25771                 }
25772                 if (r->in.local_machine) {
25773                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
25774                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
25775                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
25776                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
25777                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
25778                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.local_machine), ndr_get_array_length(ndr, &r->in.local_machine));
25779                         }
25780                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
25781                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.local_machine, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t), CH_UTF16));
25782                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
25783                 }
25784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
25785                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
25786                 if (_ptr_notify_options) {
25787                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
25788                 } else {
25789                         r->in.notify_options = NULL;
25790                 }
25791                 if (r->in.notify_options) {
25792                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
25793                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
25794                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
25795                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
25796                 }
25797         }
25798         if (flags & NDR_OUT) {
25799                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25800         }
25801         return NDR_ERR_SUCCESS;
25802 }
25803
25804 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
25805 {
25806         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
25807         ndr->depth++;
25808         if (flags & NDR_SET_VALUES) {
25809                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25810         }
25811         if (flags & NDR_IN) {
25812                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
25813                 ndr->depth++;
25814                 ndr_print_ptr(ndr, "handle", r->in.handle);
25815                 ndr->depth++;
25816                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25817                 ndr->depth--;
25818                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
25819                 ndr_print_uint32(ndr, "options", r->in.options);
25820                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
25821                 ndr->depth++;
25822                 if (r->in.local_machine) {
25823                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
25824                 }
25825                 ndr->depth--;
25826                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
25827                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
25828                 ndr->depth++;
25829                 if (r->in.notify_options) {
25830                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
25831                 }
25832                 ndr->depth--;
25833                 ndr->depth--;
25834         }
25835         if (flags & NDR_OUT) {
25836                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
25837                 ndr->depth++;
25838                 ndr_print_WERROR(ndr, "result", r->out.result);
25839                 ndr->depth--;
25840         }
25841         ndr->depth--;
25842 }
25843
25844 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
25845 {
25846         if (flags & NDR_IN) {
25847                 if (r->in.handle == NULL) {
25848                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25849                 }
25850                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25851                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
25852                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
25853                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
25854                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
25855                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
25856         }
25857         if (flags & NDR_OUT) {
25858                 if (r->out.reply_result == NULL) {
25859                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25860                 }
25861                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
25862                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25863         }
25864         return NDR_ERR_SUCCESS;
25865 }
25866
25867 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
25868 {
25869         TALLOC_CTX *_mem_save_handle_0;
25870         TALLOC_CTX *_mem_save_reply_result_0;
25871         if (flags & NDR_IN) {
25872                 ZERO_STRUCT(r->out);
25873
25874                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25875                         NDR_PULL_ALLOC(ndr, r->in.handle);
25876                 }
25877                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25878                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25879                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25880                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
25882                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
25883                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
25884                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
25885                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
25886                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
25887                 ZERO_STRUCTP(r->out.reply_result);
25888         }
25889         if (flags & NDR_OUT) {
25890                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25891                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
25892                 }
25893                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
25894                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
25895                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
25896                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
25897                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25898         }
25899         return NDR_ERR_SUCCESS;
25900 }
25901
25902 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
25903 {
25904         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
25905         ndr->depth++;
25906         if (flags & NDR_SET_VALUES) {
25907                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25908         }
25909         if (flags & NDR_IN) {
25910                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
25911                 ndr->depth++;
25912                 ndr_print_ptr(ndr, "handle", r->in.handle);
25913                 ndr->depth++;
25914                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25915                 ndr->depth--;
25916                 ndr_print_uint32(ndr, "color", r->in.color);
25917                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
25918                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
25919                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
25920                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
25921                 ndr->depth--;
25922         }
25923         if (flags & NDR_OUT) {
25924                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
25925                 ndr->depth++;
25926                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
25927                 ndr->depth++;
25928                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
25929                 ndr->depth--;
25930                 ndr_print_WERROR(ndr, "result", r->out.result);
25931                 ndr->depth--;
25932         }
25933         ndr->depth--;
25934 }
25935
25936 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25937 {
25938         if (flags & NDR_IN) {
25939                 if (r->in.handle == NULL) {
25940                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25941                 }
25942                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
25944                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
25945                 if (r->in.options) {
25946                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25947                 }
25948         }
25949         if (flags & NDR_OUT) {
25950                 if (r->out.info == NULL) {
25951                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25952                 }
25953                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
25954                 if (*r->out.info) {
25955                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25956                 }
25957                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25958         }
25959         return NDR_ERR_SUCCESS;
25960 }
25961
25962 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
25963 {
25964         uint32_t _ptr_options;
25965         uint32_t _ptr_info;
25966         TALLOC_CTX *_mem_save_handle_0;
25967         TALLOC_CTX *_mem_save_options_0;
25968         TALLOC_CTX *_mem_save_info_0;
25969         TALLOC_CTX *_mem_save_info_1;
25970         if (flags & NDR_IN) {
25971                 ZERO_STRUCT(r->out);
25972
25973                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25974                         NDR_PULL_ALLOC(ndr, r->in.handle);
25975                 }
25976                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25977                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25978                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25979                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
25981                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
25982                 if (_ptr_options) {
25983                         NDR_PULL_ALLOC(ndr, r->in.options);
25984                 } else {
25985                         r->in.options = NULL;
25986                 }
25987                 if (r->in.options) {
25988                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
25989                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
25990                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25991                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
25992                 }
25993                 NDR_PULL_ALLOC(ndr, r->out.info);
25994                 ZERO_STRUCTP(r->out.info);
25995         }
25996         if (flags & NDR_OUT) {
25997                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25998                         NDR_PULL_ALLOC(ndr, r->out.info);
25999                 }
26000                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26001                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
26002                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
26003                 if (_ptr_info) {
26004                         NDR_PULL_ALLOC(ndr, *r->out.info);
26005                 } else {
26006                         *r->out.info = NULL;
26007                 }
26008                 if (*r->out.info) {
26009                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
26010                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
26011                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
26012                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
26013                 }
26014                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
26015                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26016         }
26017         return NDR_ERR_SUCCESS;
26018 }
26019
26020 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
26021 {
26022         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
26023         ndr->depth++;
26024         if (flags & NDR_SET_VALUES) {
26025                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26026         }
26027         if (flags & NDR_IN) {
26028                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
26029                 ndr->depth++;
26030                 ndr_print_ptr(ndr, "handle", r->in.handle);
26031                 ndr->depth++;
26032                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26033                 ndr->depth--;
26034                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
26035                 ndr_print_ptr(ndr, "options", r->in.options);
26036                 ndr->depth++;
26037                 if (r->in.options) {
26038                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
26039                 }
26040                 ndr->depth--;
26041                 ndr->depth--;
26042         }
26043         if (flags & NDR_OUT) {
26044                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
26045                 ndr->depth++;
26046                 ndr_print_ptr(ndr, "info", r->out.info);
26047                 ndr->depth++;
26048                 ndr_print_ptr(ndr, "info", *r->out.info);
26049                 ndr->depth++;
26050                 if (*r->out.info) {
26051                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
26052                 }
26053                 ndr->depth--;
26054                 ndr->depth--;
26055                 ndr_print_WERROR(ndr, "result", r->out.result);
26056                 ndr->depth--;
26057         }
26058         ndr->depth--;
26059 }
26060
26061 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
26062 {
26063         if (flags & NDR_IN) {
26064         }
26065         if (flags & NDR_OUT) {
26066                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26067         }
26068         return NDR_ERR_SUCCESS;
26069 }
26070
26071 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
26072 {
26073         if (flags & NDR_IN) {
26074         }
26075         if (flags & NDR_OUT) {
26076                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26077         }
26078         return NDR_ERR_SUCCESS;
26079 }
26080
26081 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
26082 {
26083         ndr_print_struct(ndr, name, "spoolss_44");
26084         ndr->depth++;
26085         if (flags & NDR_SET_VALUES) {
26086                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26087         }
26088         if (flags & NDR_IN) {
26089                 ndr_print_struct(ndr, "in", "spoolss_44");
26090                 ndr->depth++;
26091                 ndr->depth--;
26092         }
26093         if (flags & NDR_OUT) {
26094                 ndr_print_struct(ndr, "out", "spoolss_44");
26095                 ndr->depth++;
26096                 ndr_print_WERROR(ndr, "result", r->out.result);
26097                 ndr->depth--;
26098         }
26099         ndr->depth--;
26100 }
26101
26102 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
26103 {
26104         if (flags & NDR_IN) {
26105                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
26106                 if (r->in.printername) {
26107                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
26108                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26109                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
26110                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26111                 }
26112                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
26113                 if (r->in.datatype) {
26114                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
26115                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26116                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
26117                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26118                 }
26119                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
26120                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
26121                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26122                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
26123                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
26124         }
26125         if (flags & NDR_OUT) {
26126                 if (r->out.handle == NULL) {
26127                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26128                 }
26129                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26130                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26131         }
26132         return NDR_ERR_SUCCESS;
26133 }
26134
26135 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
26136 {
26137         uint32_t _ptr_printername;
26138         uint32_t _ptr_datatype;
26139         TALLOC_CTX *_mem_save_printername_0;
26140         TALLOC_CTX *_mem_save_datatype_0;
26141         TALLOC_CTX *_mem_save_handle_0;
26142         if (flags & NDR_IN) {
26143                 ZERO_STRUCT(r->out);
26144
26145                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
26146                 if (_ptr_printername) {
26147                         NDR_PULL_ALLOC(ndr, r->in.printername);
26148                 } else {
26149                         r->in.printername = NULL;
26150                 }
26151                 if (r->in.printername) {
26152                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
26153                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
26154                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
26155                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
26156                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
26157                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.printername), ndr_get_array_length(ndr, &r->in.printername));
26158                         }
26159                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
26160                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
26161                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
26162                 }
26163                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
26164                 if (_ptr_datatype) {
26165                         NDR_PULL_ALLOC(ndr, r->in.datatype);
26166                 } else {
26167                         r->in.datatype = NULL;
26168                 }
26169                 if (r->in.datatype) {
26170                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
26171                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
26172                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
26173                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
26174                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
26175                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.datatype), ndr_get_array_length(ndr, &r->in.datatype));
26176                         }
26177                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
26178                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
26179                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
26180                 }
26181                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
26182                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
26183                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26184                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
26185                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
26186                 NDR_PULL_ALLOC(ndr, r->out.handle);
26187                 ZERO_STRUCTP(r->out.handle);
26188         }
26189         if (flags & NDR_OUT) {
26190                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26191                         NDR_PULL_ALLOC(ndr, r->out.handle);
26192                 }
26193                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26194                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26195                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26196                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26197                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26198         }
26199         return NDR_ERR_SUCCESS;
26200 }
26201
26202 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
26203 {
26204         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
26205         ndr->depth++;
26206         if (flags & NDR_SET_VALUES) {
26207                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26208         }
26209         if (flags & NDR_IN) {
26210                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
26211                 ndr->depth++;
26212                 ndr_print_ptr(ndr, "printername", r->in.printername);
26213                 ndr->depth++;
26214                 if (r->in.printername) {
26215                         ndr_print_string(ndr, "printername", r->in.printername);
26216                 }
26217                 ndr->depth--;
26218                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
26219                 ndr->depth++;
26220                 if (r->in.datatype) {
26221                         ndr_print_string(ndr, "datatype", r->in.datatype);
26222                 }
26223                 ndr->depth--;
26224                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
26225                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
26226                 ndr_print_uint32(ndr, "level", r->in.level);
26227                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
26228                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
26229                 ndr->depth--;
26230         }
26231         if (flags & NDR_OUT) {
26232                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
26233                 ndr->depth++;
26234                 ndr_print_ptr(ndr, "handle", r->out.handle);
26235                 ndr->depth++;
26236                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26237                 ndr->depth--;
26238                 ndr_print_WERROR(ndr, "result", r->out.result);
26239                 ndr->depth--;
26240         }
26241         ndr->depth--;
26242 }
26243
26244 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
26245 {
26246         if (flags & NDR_IN) {
26247                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
26248                 if (r->in.server) {
26249                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26250                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26251                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26252                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26253                 }
26254                 if (r->in.info_ctr == NULL) {
26255                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26256                 }
26257                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26258                 if (r->in.devmode_ctr == NULL) {
26259                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26260                 }
26261                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26262                 if (r->in.secdesc_ctr == NULL) {
26263                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26264                 }
26265                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
26266                 if (r->in.userlevel_ctr == NULL) {
26267                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26268                 }
26269                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
26270         }
26271         if (flags & NDR_OUT) {
26272                 if (r->out.handle == NULL) {
26273                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26274                 }
26275                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26276                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26277         }
26278         return NDR_ERR_SUCCESS;
26279 }
26280
26281 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
26282 {
26283         uint32_t _ptr_server;
26284         TALLOC_CTX *_mem_save_server_0;
26285         TALLOC_CTX *_mem_save_info_ctr_0;
26286         TALLOC_CTX *_mem_save_devmode_ctr_0;
26287         TALLOC_CTX *_mem_save_secdesc_ctr_0;
26288         TALLOC_CTX *_mem_save_userlevel_ctr_0;
26289         TALLOC_CTX *_mem_save_handle_0;
26290         if (flags & NDR_IN) {
26291                 ZERO_STRUCT(r->out);
26292
26293                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
26294                 if (_ptr_server) {
26295                         NDR_PULL_ALLOC(ndr, r->in.server);
26296                 } else {
26297                         r->in.server = NULL;
26298                 }
26299                 if (r->in.server) {
26300                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
26301                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
26302                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
26303                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
26304                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
26305                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
26306                         }
26307                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
26308                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
26309                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
26310                 }
26311                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26312                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
26313                 }
26314                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26315                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
26316                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26317                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26318                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26319                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
26320                 }
26321                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26322                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
26323                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26324                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26325                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26326                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
26327                 }
26328                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26329                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
26330                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
26331                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26332                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26333                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
26334                 }
26335                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26336                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
26337                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
26338                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26339                 NDR_PULL_ALLOC(ndr, r->out.handle);
26340                 ZERO_STRUCTP(r->out.handle);
26341         }
26342         if (flags & NDR_OUT) {
26343                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26344                         NDR_PULL_ALLOC(ndr, r->out.handle);
26345                 }
26346                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26347                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26348                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26349                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26350                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26351         }
26352         return NDR_ERR_SUCCESS;
26353 }
26354
26355 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
26356 {
26357         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
26358         ndr->depth++;
26359         if (flags & NDR_SET_VALUES) {
26360                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26361         }
26362         if (flags & NDR_IN) {
26363                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
26364                 ndr->depth++;
26365                 ndr_print_ptr(ndr, "server", r->in.server);
26366                 ndr->depth++;
26367                 if (r->in.server) {
26368                         ndr_print_string(ndr, "server", r->in.server);
26369                 }
26370                 ndr->depth--;
26371                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
26372                 ndr->depth++;
26373                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
26374                 ndr->depth--;
26375                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
26376                 ndr->depth++;
26377                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
26378                 ndr->depth--;
26379                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
26380                 ndr->depth++;
26381                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
26382                 ndr->depth--;
26383                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
26384                 ndr->depth++;
26385                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
26386                 ndr->depth--;
26387                 ndr->depth--;
26388         }
26389         if (flags & NDR_OUT) {
26390                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
26391                 ndr->depth++;
26392                 ndr_print_ptr(ndr, "handle", r->out.handle);
26393                 ndr->depth++;
26394                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26395                 ndr->depth--;
26396                 ndr_print_WERROR(ndr, "result", r->out.result);
26397                 ndr->depth--;
26398         }
26399         ndr->depth--;
26400 }
26401
26402 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
26403 {
26404         if (flags & NDR_IN) {
26405         }
26406         if (flags & NDR_OUT) {
26407                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26408         }
26409         return NDR_ERR_SUCCESS;
26410 }
26411
26412 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
26413 {
26414         if (flags & NDR_IN) {
26415         }
26416         if (flags & NDR_OUT) {
26417                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26418         }
26419         return NDR_ERR_SUCCESS;
26420 }
26421
26422 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
26423 {
26424         ndr_print_struct(ndr, name, "spoolss_47");
26425         ndr->depth++;
26426         if (flags & NDR_SET_VALUES) {
26427                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26428         }
26429         if (flags & NDR_IN) {
26430                 ndr_print_struct(ndr, "in", "spoolss_47");
26431                 ndr->depth++;
26432                 ndr->depth--;
26433         }
26434         if (flags & NDR_OUT) {
26435                 ndr_print_struct(ndr, "out", "spoolss_47");
26436                 ndr->depth++;
26437                 ndr_print_WERROR(ndr, "result", r->out.result);
26438                 ndr->depth--;
26439         }
26440         ndr->depth--;
26441 }
26442
26443 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
26444 {
26445         if (flags & NDR_IN) {
26446                 if (r->in.handle == NULL) {
26447                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26448                 }
26449                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26450                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
26451                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
26452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
26453         }
26454         if (flags & NDR_OUT) {
26455                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
26456                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
26457                 if (r->out.value_needed == NULL) {
26458                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26459                 }
26460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
26461                 if (r->out.type == NULL) {
26462                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26463                 }
26464                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
26465                 {
26466                         uint32_t _flags_save_uint8 = ndr->flags;
26467                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
26468                         if (r->out.data == NULL) {
26469                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26470                         }
26471                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
26472                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
26473                         ndr->flags = _flags_save_uint8;
26474                 }
26475                 if (r->out.data_needed == NULL) {
26476                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26477                 }
26478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
26479                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26480         }
26481         return NDR_ERR_SUCCESS;
26482 }
26483
26484 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
26485 {
26486         TALLOC_CTX *_mem_save_handle_0;
26487         TALLOC_CTX *_mem_save_value_needed_0;
26488         TALLOC_CTX *_mem_save_type_0;
26489         TALLOC_CTX *_mem_save_data_needed_0;
26490         if (flags & NDR_IN) {
26491                 ZERO_STRUCT(r->out);
26492
26493                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26494                         NDR_PULL_ALLOC(ndr, r->in.handle);
26495                 }
26496                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26497                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26498                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26499                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26500                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
26501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
26502                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
26503                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
26504                 ZERO_STRUCTP(r->out.value_needed);
26505                 NDR_PULL_ALLOC(ndr, r->out.type);
26506                 ZERO_STRUCTP(r->out.type);
26507                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
26508                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
26509                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
26510                 ZERO_STRUCTP(r->out.data_needed);
26511         }
26512         if (flags & NDR_OUT) {
26513                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
26514                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->out.value_name, ndr_get_array_size(ndr, &r->out.value_name), sizeof(uint16_t), CH_UTF16));
26515                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26516                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
26517                 }
26518                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26519                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
26520                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
26521                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
26522                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26523                         NDR_PULL_ALLOC(ndr, r->out.type);
26524                 }
26525                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26526                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
26527                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
26528                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
26529                 {
26530                         uint32_t _flags_save_uint8 = ndr->flags;
26531                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
26532                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
26533                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26534                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
26535                         }
26536                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
26537                         ndr->flags = _flags_save_uint8;
26538                 }
26539                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26540                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
26541                 }
26542                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26543                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
26544                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
26545                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
26546                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26547                 if (r->out.value_name) {
26548                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
26549                 }
26550                 if (r->out.data) {
26551                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
26552                 }
26553         }
26554         return NDR_ERR_SUCCESS;
26555 }
26556
26557 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
26558 {
26559         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
26560         ndr->depth++;
26561         if (flags & NDR_SET_VALUES) {
26562                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26563         }
26564         if (flags & NDR_IN) {
26565                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
26566                 ndr->depth++;
26567                 ndr_print_ptr(ndr, "handle", r->in.handle);
26568                 ndr->depth++;
26569                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26570                 ndr->depth--;
26571                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
26572                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
26573                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
26574                 ndr->depth--;
26575         }
26576         if (flags & NDR_OUT) {
26577                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
26578                 ndr->depth++;
26579                 ndr_print_string(ndr, "value_name", r->out.value_name);
26580                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
26581                 ndr->depth++;
26582                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
26583                 ndr->depth--;
26584                 ndr_print_ptr(ndr, "type", r->out.type);
26585                 ndr->depth++;
26586                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
26587                 ndr->depth--;
26588                 ndr_print_ptr(ndr, "data", r->out.data);
26589                 ndr->depth++;
26590                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
26591                 ndr->depth--;
26592                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
26593                 ndr->depth++;
26594                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
26595                 ndr->depth--;
26596                 ndr_print_WERROR(ndr, "result", r->out.result);
26597                 ndr->depth--;
26598         }
26599         ndr->depth--;
26600 }
26601
26602 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
26603 {
26604         if (flags & NDR_IN) {
26605                 if (r->in.handle == NULL) {
26606                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26607                 }
26608                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26610                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26611                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26612                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.value_name, ndr_charset_length(r->in.value_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26613         }
26614         if (flags & NDR_OUT) {
26615                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26616         }
26617         return NDR_ERR_SUCCESS;
26618 }
26619
26620 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
26621 {
26622         TALLOC_CTX *_mem_save_handle_0;
26623         if (flags & NDR_IN) {
26624                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26625                         NDR_PULL_ALLOC(ndr, r->in.handle);
26626                 }
26627                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26628                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26629                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26630                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26631                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26632                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26633                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26634                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
26635                 }
26636                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26637                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t), CH_UTF16));
26638         }
26639         if (flags & NDR_OUT) {
26640                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26641         }
26642         return NDR_ERR_SUCCESS;
26643 }
26644
26645 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
26646 {
26647         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
26648         ndr->depth++;
26649         if (flags & NDR_SET_VALUES) {
26650                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26651         }
26652         if (flags & NDR_IN) {
26653                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
26654                 ndr->depth++;
26655                 ndr_print_ptr(ndr, "handle", r->in.handle);
26656                 ndr->depth++;
26657                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26658                 ndr->depth--;
26659                 ndr_print_string(ndr, "value_name", r->in.value_name);
26660                 ndr->depth--;
26661         }
26662         if (flags & NDR_OUT) {
26663                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
26664                 ndr->depth++;
26665                 ndr_print_WERROR(ndr, "result", r->out.result);
26666                 ndr->depth--;
26667         }
26668         ndr->depth--;
26669 }
26670
26671 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
26672 {
26673         if (flags & NDR_IN) {
26674         }
26675         if (flags & NDR_OUT) {
26676                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26677         }
26678         return NDR_ERR_SUCCESS;
26679 }
26680
26681 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
26682 {
26683         if (flags & NDR_IN) {
26684         }
26685         if (flags & NDR_OUT) {
26686                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26687         }
26688         return NDR_ERR_SUCCESS;
26689 }
26690
26691 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
26692 {
26693         ndr_print_struct(ndr, name, "spoolss_4a");
26694         ndr->depth++;
26695         if (flags & NDR_SET_VALUES) {
26696                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26697         }
26698         if (flags & NDR_IN) {
26699                 ndr_print_struct(ndr, "in", "spoolss_4a");
26700                 ndr->depth++;
26701                 ndr->depth--;
26702         }
26703         if (flags & NDR_OUT) {
26704                 ndr_print_struct(ndr, "out", "spoolss_4a");
26705                 ndr->depth++;
26706                 ndr_print_WERROR(ndr, "result", r->out.result);
26707                 ndr->depth--;
26708         }
26709         ndr->depth--;
26710 }
26711
26712 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
26713 {
26714         if (flags & NDR_IN) {
26715         }
26716         if (flags & NDR_OUT) {
26717                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26718         }
26719         return NDR_ERR_SUCCESS;
26720 }
26721
26722 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
26723 {
26724         if (flags & NDR_IN) {
26725         }
26726         if (flags & NDR_OUT) {
26727                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26728         }
26729         return NDR_ERR_SUCCESS;
26730 }
26731
26732 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
26733 {
26734         ndr_print_struct(ndr, name, "spoolss_4b");
26735         ndr->depth++;
26736         if (flags & NDR_SET_VALUES) {
26737                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26738         }
26739         if (flags & NDR_IN) {
26740                 ndr_print_struct(ndr, "in", "spoolss_4b");
26741                 ndr->depth++;
26742                 ndr->depth--;
26743         }
26744         if (flags & NDR_OUT) {
26745                 ndr_print_struct(ndr, "out", "spoolss_4b");
26746                 ndr->depth++;
26747                 ndr_print_WERROR(ndr, "result", r->out.result);
26748                 ndr->depth--;
26749         }
26750         ndr->depth--;
26751 }
26752
26753 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
26754 {
26755         if (flags & NDR_IN) {
26756         }
26757         if (flags & NDR_OUT) {
26758                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26759         }
26760         return NDR_ERR_SUCCESS;
26761 }
26762
26763 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
26764 {
26765         if (flags & NDR_IN) {
26766         }
26767         if (flags & NDR_OUT) {
26768                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26769         }
26770         return NDR_ERR_SUCCESS;
26771 }
26772
26773 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
26774 {
26775         ndr_print_struct(ndr, name, "spoolss_4c");
26776         ndr->depth++;
26777         if (flags & NDR_SET_VALUES) {
26778                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26779         }
26780         if (flags & NDR_IN) {
26781                 ndr_print_struct(ndr, "in", "spoolss_4c");
26782                 ndr->depth++;
26783                 ndr->depth--;
26784         }
26785         if (flags & NDR_OUT) {
26786                 ndr_print_struct(ndr, "out", "spoolss_4c");
26787                 ndr->depth++;
26788                 ndr_print_WERROR(ndr, "result", r->out.result);
26789                 ndr->depth--;
26790         }
26791         ndr->depth--;
26792 }
26793
26794 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
26795 {
26796         if (flags & NDR_IN) {
26797                 if (r->in.handle == NULL) {
26798                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26799                 }
26800                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26801                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26804                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.key_name, ndr_charset_length(r->in.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26805                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26806                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26808                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.value_name, ndr_charset_length(r->in.value_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26809                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
26810                 if (r->in.buffer == NULL) {
26811                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26812                 }
26813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26814                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
26815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26816         }
26817         if (flags & NDR_OUT) {
26818                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26819         }
26820         return NDR_ERR_SUCCESS;
26821 }
26822
26823 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
26824 {
26825         TALLOC_CTX *_mem_save_handle_0;
26826         if (flags & NDR_IN) {
26827                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26828                         NDR_PULL_ALLOC(ndr, r->in.handle);
26829                 }
26830                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26831                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26832                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26833                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26834                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26835                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26836                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26837                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
26838                 }
26839                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26840                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
26841                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26842                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26843                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26844                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
26845                 }
26846                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26847                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t), CH_UTF16));
26848                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
26849                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26850                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26851                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26852                 }
26853                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26855                 if (r->in.buffer) {
26856                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
26857                 }
26858         }
26859         if (flags & NDR_OUT) {
26860                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26861         }
26862         return NDR_ERR_SUCCESS;
26863 }
26864
26865 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
26866 {
26867         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
26868         ndr->depth++;
26869         if (flags & NDR_SET_VALUES) {
26870                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26871         }
26872         if (flags & NDR_IN) {
26873                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
26874                 ndr->depth++;
26875                 ndr_print_ptr(ndr, "handle", r->in.handle);
26876                 ndr->depth++;
26877                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26878                 ndr->depth--;
26879                 ndr_print_string(ndr, "key_name", r->in.key_name);
26880                 ndr_print_string(ndr, "value_name", r->in.value_name);
26881                 ndr_print_winreg_Type(ndr, "type", r->in.type);
26882                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26883                 ndr->depth++;
26884                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
26885                 ndr->depth--;
26886                 ndr_print_uint32(ndr, "offered", r->in.offered);
26887                 ndr->depth--;
26888         }
26889         if (flags & NDR_OUT) {
26890                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
26891                 ndr->depth++;
26892                 ndr_print_WERROR(ndr, "result", r->out.result);
26893                 ndr->depth--;
26894         }
26895         ndr->depth--;
26896 }
26897
26898 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
26899 {
26900         if (flags & NDR_IN) {
26901                 if (r->in.handle == NULL) {
26902                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26903                 }
26904                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26905                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26906                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26908                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.key_name, ndr_charset_length(r->in.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26912                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.value_name, ndr_charset_length(r->in.value_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26913                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26914         }
26915         if (flags & NDR_OUT) {
26916                 if (r->out.type == NULL) {
26917                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26918                 }
26919                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
26920                 if (r->out.buffer == NULL) {
26921                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26922                 }
26923                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26924                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
26925                 if (r->out.needed == NULL) {
26926                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26927                 }
26928                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26929                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26930         }
26931         return NDR_ERR_SUCCESS;
26932 }
26933
26934 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
26935 {
26936         TALLOC_CTX *_mem_save_handle_0;
26937         TALLOC_CTX *_mem_save_type_0;
26938         TALLOC_CTX *_mem_save_needed_0;
26939         if (flags & NDR_IN) {
26940                 ZERO_STRUCT(r->out);
26941
26942                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26943                         NDR_PULL_ALLOC(ndr, r->in.handle);
26944                 }
26945                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26946                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26947                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26948                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26949                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26950                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26951                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26952                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
26953                 }
26954                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26955                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
26956                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26957                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26958                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26959                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
26960                 }
26961                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26962                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t), CH_UTF16));
26963                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26964                 NDR_PULL_ALLOC(ndr, r->out.type);
26965                 ZERO_STRUCTP(r->out.type);
26966                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
26967                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
26968                 NDR_PULL_ALLOC(ndr, r->out.needed);
26969                 ZERO_STRUCTP(r->out.needed);
26970         }
26971         if (flags & NDR_OUT) {
26972                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26973                         NDR_PULL_ALLOC(ndr, r->out.type);
26974                 }
26975                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26976                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
26977                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
26978                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
26979                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
26980                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26981                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
26982                 }
26983                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
26984                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26985                         NDR_PULL_ALLOC(ndr, r->out.needed);
26986                 }
26987                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26988                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26989                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26990                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26991                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26992                 if (r->out.buffer) {
26993                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
26994                 }
26995         }
26996         return NDR_ERR_SUCCESS;
26997 }
26998
26999 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
27000 {
27001         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
27002         ndr->depth++;
27003         if (flags & NDR_SET_VALUES) {
27004                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27005         }
27006         if (flags & NDR_IN) {
27007                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
27008                 ndr->depth++;
27009                 ndr_print_ptr(ndr, "handle", r->in.handle);
27010                 ndr->depth++;
27011                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27012                 ndr->depth--;
27013                 ndr_print_string(ndr, "key_name", r->in.key_name);
27014                 ndr_print_string(ndr, "value_name", r->in.value_name);
27015                 ndr_print_uint32(ndr, "offered", r->in.offered);
27016                 ndr->depth--;
27017         }
27018         if (flags & NDR_OUT) {
27019                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
27020                 ndr->depth++;
27021                 ndr_print_ptr(ndr, "type", r->out.type);
27022                 ndr->depth++;
27023                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
27024                 ndr->depth--;
27025                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
27026                 ndr->depth++;
27027                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
27028                 ndr->depth--;
27029                 ndr_print_ptr(ndr, "needed", r->out.needed);
27030                 ndr->depth++;
27031                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27032                 ndr->depth--;
27033                 ndr_print_WERROR(ndr, "result", r->out.result);
27034                 ndr->depth--;
27035         }
27036         ndr->depth--;
27037 }
27038
27039 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
27040 {
27041         if (flags & NDR_IN) {
27042                 if (r->in.handle == NULL) {
27043                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27044                 }
27045                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27046                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27048                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27049                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.key_name, ndr_charset_length(r->in.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27050                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27051         }
27052         if (flags & NDR_OUT) {
27053                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
27054                 if (r->out.needed == NULL) {
27055                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27056                 }
27057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27058                 if (r->out.count == NULL) {
27059                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27060                 }
27061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
27062                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27063         }
27064         return NDR_ERR_SUCCESS;
27065 }
27066
27067 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
27068 {
27069         TALLOC_CTX *_mem_save_handle_0;
27070         TALLOC_CTX *_mem_save_needed_0;
27071         TALLOC_CTX *_mem_save_count_0;
27072         if (flags & NDR_IN) {
27073                 ZERO_STRUCT(r->out);
27074
27075                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27076                         NDR_PULL_ALLOC(ndr, r->in.handle);
27077                 }
27078                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27079                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27080                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27081                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27082                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27083                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27084                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27085                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
27086                 }
27087                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27088                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
27089                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27090                 NDR_PULL_ALLOC(ndr, r->out.needed);
27091                 ZERO_STRUCTP(r->out.needed);
27092                 NDR_PULL_ALLOC(ndr, r->out.count);
27093                 ZERO_STRUCTP(r->out.count);
27094         }
27095         if (flags & NDR_OUT) {
27096                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
27097                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27098                         NDR_PULL_ALLOC(ndr, r->out.needed);
27099                 }
27100                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27101                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27102                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27103                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27104                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27105                         NDR_PULL_ALLOC(ndr, r->out.count);
27106                 }
27107                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
27108                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
27109                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
27110                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
27111                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27112         }
27113         return NDR_ERR_SUCCESS;
27114 }
27115
27116 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
27117 {
27118         uint32_t cntr_info_0;
27119         if (flags & NDR_IN) {
27120                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
27121         }
27122         if (flags & NDR_OUT) {
27123                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27124                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
27125                 }
27126                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27127                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
27128                 }
27129         }
27130         return NDR_ERR_SUCCESS;
27131 }
27132
27133 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
27134 {
27135         uint32_t cntr_info_0;
27136         TALLOC_CTX *_mem_save_info_0;
27137         if (flags & NDR_IN) {
27138                 ZERO_STRUCT(r->out);
27139
27140                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
27141         }
27142         if (flags & NDR_OUT) {
27143                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
27144                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
27145                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
27146                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27147                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
27148                 }
27149                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27150                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
27151                 }
27152                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
27153         }
27154         return NDR_ERR_SUCCESS;
27155 }
27156
27157 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
27158 {
27159         uint32_t cntr_info_2;
27160         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
27161         ndr->depth++;
27162         if (flags & NDR_SET_VALUES) {
27163                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27164         }
27165         if (flags & NDR_IN) {
27166                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
27167                 ndr->depth++;
27168                 ndr_print_ptr(ndr, "handle", r->in.handle);
27169                 ndr->depth++;
27170                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27171                 ndr->depth--;
27172                 ndr_print_string(ndr, "key_name", r->in.key_name);
27173                 ndr_print_uint32(ndr, "offered", r->in.offered);
27174                 ndr->depth--;
27175         }
27176         if (flags & NDR_OUT) {
27177                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
27178                 ndr->depth++;
27179                 ndr_print_ptr(ndr, "count", r->out.count);
27180                 ndr->depth++;
27181                 ndr_print_uint32(ndr, "count", *r->out.count);
27182                 ndr->depth--;
27183                 ndr_print_ptr(ndr, "info", r->out.info);
27184                 ndr->depth++;
27185                 ndr_print_ptr(ndr, "info", *r->out.info);
27186                 ndr->depth++;
27187                 if (*r->out.info) {
27188                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
27189                         ndr->depth++;
27190                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
27191                                 char *idx_2=NULL;
27192                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
27193                                         ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
27194                                         free(idx_2);
27195                                 }
27196                         }
27197                         ndr->depth--;
27198                 }
27199                 ndr->depth--;
27200                 ndr->depth--;
27201                 ndr_print_ptr(ndr, "needed", r->out.needed);
27202                 ndr->depth++;
27203                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27204                 ndr->depth--;
27205                 ndr_print_WERROR(ndr, "result", r->out.result);
27206                 ndr->depth--;
27207         }
27208         ndr->depth--;
27209 }
27210
27211 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
27212 {
27213         if (flags & NDR_IN) {
27214                 if (r->in.handle == NULL) {
27215                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27216                 }
27217                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27218                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27219                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27221                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.key_name, ndr_charset_length(r->in.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27222                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27223         }
27224         if (flags & NDR_OUT) {
27225                 if (r->out._ndr_size == NULL) {
27226                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27227                 }
27228                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._ndr_size));
27229                 if (r->out.key_buffer == NULL) {
27230                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27231                 }
27232                 {
27233                         struct ndr_push *_ndr_key_buffer;
27234                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
27235                         NDR_CHECK(ndr_push_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
27236                         NDR_CHECK(ndr_push_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
27237                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
27238                 }
27239                 if (r->out.needed == NULL) {
27240                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27241                 }
27242                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27243                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27244         }
27245         return NDR_ERR_SUCCESS;
27246 }
27247
27248 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
27249 {
27250         TALLOC_CTX *_mem_save_handle_0;
27251         TALLOC_CTX *_mem_save__ndr_size_0;
27252         TALLOC_CTX *_mem_save_key_buffer_0;
27253         TALLOC_CTX *_mem_save_needed_0;
27254         if (flags & NDR_IN) {
27255                 ZERO_STRUCT(r->out);
27256
27257                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27258                         NDR_PULL_ALLOC(ndr, r->in.handle);
27259                 }
27260                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27261                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27262                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27263                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27264                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27265                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27266                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27267                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
27268                 }
27269                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27270                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
27271                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27272                 NDR_PULL_ALLOC(ndr, r->out._ndr_size);
27273                 ZERO_STRUCTP(r->out._ndr_size);
27274                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
27275                 ZERO_STRUCTP(r->out.key_buffer);
27276                 NDR_PULL_ALLOC(ndr, r->out.needed);
27277                 ZERO_STRUCTP(r->out.needed);
27278         }
27279         if (flags & NDR_OUT) {
27280                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27281                         NDR_PULL_ALLOC(ndr, r->out._ndr_size);
27282                 }
27283                 _mem_save__ndr_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
27284                 NDR_PULL_SET_MEM_CTX(ndr, r->out._ndr_size, LIBNDR_FLAG_REF_ALLOC);
27285                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._ndr_size));
27286                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__ndr_size_0, LIBNDR_FLAG_REF_ALLOC);
27287                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27288                         NDR_PULL_ALLOC(ndr, r->out.key_buffer);
27289                 }
27290                 _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
27291                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
27292                 {
27293                         struct ndr_pull *_ndr_key_buffer;
27294                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
27295                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
27296                         NDR_CHECK(ndr_pull_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
27297                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
27298                 }
27299                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
27300                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27301                         NDR_PULL_ALLOC(ndr, r->out.needed);
27302                 }
27303                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27304                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27305                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27306                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27307                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27308         }
27309         return NDR_ERR_SUCCESS;
27310 }
27311
27312 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
27313 {
27314         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
27315         ndr->depth++;
27316         if (flags & NDR_SET_VALUES) {
27317                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27318         }
27319         if (flags & NDR_IN) {
27320                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
27321                 ndr->depth++;
27322                 ndr_print_ptr(ndr, "handle", r->in.handle);
27323                 ndr->depth++;
27324                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27325                 ndr->depth--;
27326                 ndr_print_string(ndr, "key_name", r->in.key_name);
27327                 ndr_print_uint32(ndr, "offered", r->in.offered);
27328                 ndr->depth--;
27329         }
27330         if (flags & NDR_OUT) {
27331                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
27332                 ndr->depth++;
27333                 ndr_print_ptr(ndr, "_ndr_size", r->out._ndr_size);
27334                 ndr->depth++;
27335                 ndr_print_uint32(ndr, "_ndr_size", *r->out._ndr_size);
27336                 ndr->depth--;
27337                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
27338                 ndr->depth++;
27339                 ndr_print_set_switch_value(ndr, r->out.key_buffer, *r->out._ndr_size);
27340                 ndr_print_spoolss_KeyNames(ndr, "key_buffer", r->out.key_buffer);
27341                 ndr->depth--;
27342                 ndr_print_ptr(ndr, "needed", r->out.needed);
27343                 ndr->depth++;
27344                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27345                 ndr->depth--;
27346                 ndr_print_WERROR(ndr, "result", r->out.result);
27347                 ndr->depth--;
27348         }
27349         ndr->depth--;
27350 }
27351
27352 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
27353 {
27354         if (flags & NDR_IN) {
27355                 if (r->in.handle == NULL) {
27356                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27357                 }
27358                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27361                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27362                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.key_name, ndr_charset_length(r->in.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27365                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27366                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.value_name, ndr_charset_length(r->in.value_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27367         }
27368         if (flags & NDR_OUT) {
27369                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27370         }
27371         return NDR_ERR_SUCCESS;
27372 }
27373
27374 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
27375 {
27376         TALLOC_CTX *_mem_save_handle_0;
27377         if (flags & NDR_IN) {
27378                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27379                         NDR_PULL_ALLOC(ndr, r->in.handle);
27380                 }
27381                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27382                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27383                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27384                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27385                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27386                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27387                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27388                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
27389                 }
27390                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27391                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
27392                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27393                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27394                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27395                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
27396                 }
27397                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27398                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t), CH_UTF16));
27399         }
27400         if (flags & NDR_OUT) {
27401                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27402         }
27403         return NDR_ERR_SUCCESS;
27404 }
27405
27406 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
27407 {
27408         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
27409         ndr->depth++;
27410         if (flags & NDR_SET_VALUES) {
27411                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27412         }
27413         if (flags & NDR_IN) {
27414                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
27415                 ndr->depth++;
27416                 ndr_print_ptr(ndr, "handle", r->in.handle);
27417                 ndr->depth++;
27418                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27419                 ndr->depth--;
27420                 ndr_print_string(ndr, "key_name", r->in.key_name);
27421                 ndr_print_string(ndr, "value_name", r->in.value_name);
27422                 ndr->depth--;
27423         }
27424         if (flags & NDR_OUT) {
27425                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
27426                 ndr->depth++;
27427                 ndr_print_WERROR(ndr, "result", r->out.result);
27428                 ndr->depth--;
27429         }
27430         ndr->depth--;
27431 }
27432
27433 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
27434 {
27435         if (flags & NDR_IN) {
27436                 if (r->in.handle == NULL) {
27437                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27438                 }
27439                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27442                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27443                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.key_name, ndr_charset_length(r->in.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27444         }
27445         if (flags & NDR_OUT) {
27446                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27447         }
27448         return NDR_ERR_SUCCESS;
27449 }
27450
27451 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
27452 {
27453         TALLOC_CTX *_mem_save_handle_0;
27454         if (flags & NDR_IN) {
27455                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27456                         NDR_PULL_ALLOC(ndr, r->in.handle);
27457                 }
27458                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27459                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27460                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27461                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27462                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27463                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27464                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27465                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
27466                 }
27467                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27468                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
27469         }
27470         if (flags & NDR_OUT) {
27471                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27472         }
27473         return NDR_ERR_SUCCESS;
27474 }
27475
27476 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
27477 {
27478         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
27479         ndr->depth++;
27480         if (flags & NDR_SET_VALUES) {
27481                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27482         }
27483         if (flags & NDR_IN) {
27484                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
27485                 ndr->depth++;
27486                 ndr_print_ptr(ndr, "handle", r->in.handle);
27487                 ndr->depth++;
27488                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27489                 ndr->depth--;
27490                 ndr_print_string(ndr, "key_name", r->in.key_name);
27491                 ndr->depth--;
27492         }
27493         if (flags & NDR_OUT) {
27494                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
27495                 ndr->depth++;
27496                 ndr_print_WERROR(ndr, "result", r->out.result);
27497                 ndr->depth--;
27498         }
27499         ndr->depth--;
27500 }
27501
27502 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
27503 {
27504         if (flags & NDR_IN) {
27505         }
27506         if (flags & NDR_OUT) {
27507                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27508         }
27509         return NDR_ERR_SUCCESS;
27510 }
27511
27512 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
27513 {
27514         if (flags & NDR_IN) {
27515         }
27516         if (flags & NDR_OUT) {
27517                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27518         }
27519         return NDR_ERR_SUCCESS;
27520 }
27521
27522 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
27523 {
27524         ndr_print_struct(ndr, name, "spoolss_53");
27525         ndr->depth++;
27526         if (flags & NDR_SET_VALUES) {
27527                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27528         }
27529         if (flags & NDR_IN) {
27530                 ndr_print_struct(ndr, "in", "spoolss_53");
27531                 ndr->depth++;
27532                 ndr->depth--;
27533         }
27534         if (flags & NDR_OUT) {
27535                 ndr_print_struct(ndr, "out", "spoolss_53");
27536                 ndr->depth++;
27537                 ndr_print_WERROR(ndr, "result", r->out.result);
27538                 ndr->depth--;
27539         }
27540         ndr->depth--;
27541 }
27542
27543 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
27544 {
27545         if (flags & NDR_IN) {
27546                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
27547                 if (r->in.server) {
27548                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27549                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27550                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27551                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27552                 }
27553                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
27554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27555                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
27556                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
27558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27559                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
27560                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27561                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
27562                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
27563         }
27564         if (flags & NDR_OUT) {
27565                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27566         }
27567         return NDR_ERR_SUCCESS;
27568 }
27569
27570 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
27571 {
27572         uint32_t _ptr_server;
27573         TALLOC_CTX *_mem_save_server_0;
27574         if (flags & NDR_IN) {
27575                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
27576                 if (_ptr_server) {
27577                         NDR_PULL_ALLOC(ndr, r->in.server);
27578                 } else {
27579                         r->in.server = NULL;
27580                 }
27581                 if (r->in.server) {
27582                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
27583                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
27584                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
27585                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
27586                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
27587                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
27588                         }
27589                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
27590                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
27591                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
27592                 }
27593                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
27594                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
27595                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
27596                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture));
27597                 }
27598                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
27599                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
27600                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
27601                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
27602                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
27603                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.driver), ndr_get_array_length(ndr, &r->in.driver));
27604                 }
27605                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
27606                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
27607                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
27608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
27609         }
27610         if (flags & NDR_OUT) {
27611                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27612         }
27613         return NDR_ERR_SUCCESS;
27614 }
27615
27616 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
27617 {
27618         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
27619         ndr->depth++;
27620         if (flags & NDR_SET_VALUES) {
27621                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27622         }
27623         if (flags & NDR_IN) {
27624                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
27625                 ndr->depth++;
27626                 ndr_print_ptr(ndr, "server", r->in.server);
27627                 ndr->depth++;
27628                 if (r->in.server) {
27629                         ndr_print_string(ndr, "server", r->in.server);
27630                 }
27631                 ndr->depth--;
27632                 ndr_print_string(ndr, "architecture", r->in.architecture);
27633                 ndr_print_string(ndr, "driver", r->in.driver);
27634                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
27635                 ndr_print_uint32(ndr, "version", r->in.version);
27636                 ndr->depth--;
27637         }
27638         if (flags & NDR_OUT) {
27639                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
27640                 ndr->depth++;
27641                 ndr_print_WERROR(ndr, "result", r->out.result);
27642                 ndr->depth--;
27643         }
27644         ndr->depth--;
27645 }
27646
27647 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
27648 {
27649         if (flags & NDR_IN) {
27650         }
27651         if (flags & NDR_OUT) {
27652                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27653         }
27654         return NDR_ERR_SUCCESS;
27655 }
27656
27657 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
27658 {
27659         if (flags & NDR_IN) {
27660         }
27661         if (flags & NDR_OUT) {
27662                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27663         }
27664         return NDR_ERR_SUCCESS;
27665 }
27666
27667 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
27668 {
27669         ndr_print_struct(ndr, name, "spoolss_55");
27670         ndr->depth++;
27671         if (flags & NDR_SET_VALUES) {
27672                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27673         }
27674         if (flags & NDR_IN) {
27675                 ndr_print_struct(ndr, "in", "spoolss_55");
27676                 ndr->depth++;
27677                 ndr->depth--;
27678         }
27679         if (flags & NDR_OUT) {
27680                 ndr_print_struct(ndr, "out", "spoolss_55");
27681                 ndr->depth++;
27682                 ndr_print_WERROR(ndr, "result", r->out.result);
27683                 ndr->depth--;
27684         }
27685         ndr->depth--;
27686 }
27687
27688 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
27689 {
27690         if (flags & NDR_IN) {
27691         }
27692         if (flags & NDR_OUT) {
27693                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27694         }
27695         return NDR_ERR_SUCCESS;
27696 }
27697
27698 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
27699 {
27700         if (flags & NDR_IN) {
27701         }
27702         if (flags & NDR_OUT) {
27703                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27704         }
27705         return NDR_ERR_SUCCESS;
27706 }
27707
27708 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
27709 {
27710         ndr_print_struct(ndr, name, "spoolss_56");
27711         ndr->depth++;
27712         if (flags & NDR_SET_VALUES) {
27713                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27714         }
27715         if (flags & NDR_IN) {
27716                 ndr_print_struct(ndr, "in", "spoolss_56");
27717                 ndr->depth++;
27718                 ndr->depth--;
27719         }
27720         if (flags & NDR_OUT) {
27721                 ndr_print_struct(ndr, "out", "spoolss_56");
27722                 ndr->depth++;
27723                 ndr_print_WERROR(ndr, "result", r->out.result);
27724                 ndr->depth--;
27725         }
27726         ndr->depth--;
27727 }
27728
27729 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
27730 {
27731         if (flags & NDR_IN) {
27732         }
27733         if (flags & NDR_OUT) {
27734                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27735         }
27736         return NDR_ERR_SUCCESS;
27737 }
27738
27739 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
27740 {
27741         if (flags & NDR_IN) {
27742         }
27743         if (flags & NDR_OUT) {
27744                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27745         }
27746         return NDR_ERR_SUCCESS;
27747 }
27748
27749 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
27750 {
27751         ndr_print_struct(ndr, name, "spoolss_57");
27752         ndr->depth++;
27753         if (flags & NDR_SET_VALUES) {
27754                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27755         }
27756         if (flags & NDR_IN) {
27757                 ndr_print_struct(ndr, "in", "spoolss_57");
27758                 ndr->depth++;
27759                 ndr->depth--;
27760         }
27761         if (flags & NDR_OUT) {
27762                 ndr_print_struct(ndr, "out", "spoolss_57");
27763                 ndr->depth++;
27764                 ndr_print_WERROR(ndr, "result", r->out.result);
27765                 ndr->depth--;
27766         }
27767         ndr->depth--;
27768 }
27769
27770 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
27771 {
27772         if (flags & NDR_IN) {
27773                 if (r->in.handle == NULL) {
27774                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27775                 }
27776                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27777                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
27778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27779                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
27780                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.function_name, ndr_charset_length(r->in.function_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27781                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
27782                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
27783                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
27784                 if (r->in.status_code == NULL) {
27785                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27786                 }
27787                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
27788         }
27789         if (flags & NDR_OUT) {
27790                 if (r->out.out_data == NULL) {
27791                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27792                 }
27793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
27794                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
27795                 if (r->out.needed == NULL) {
27796                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27797                 }
27798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27799                 if (r->out.status_code == NULL) {
27800                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27801                 }
27802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
27803                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27804         }
27805         return NDR_ERR_SUCCESS;
27806 }
27807
27808 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
27809 {
27810         TALLOC_CTX *_mem_save_handle_0;
27811         TALLOC_CTX *_mem_save_needed_0;
27812         TALLOC_CTX *_mem_save_status_code_0;
27813         if (flags & NDR_IN) {
27814                 ZERO_STRUCT(r->out);
27815
27816                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27817                         NDR_PULL_ALLOC(ndr, r->in.handle);
27818                 }
27819                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27820                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27821                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27822                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27823                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
27824                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
27825                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
27826                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.function_name), ndr_get_array_length(ndr, &r->in.function_name));
27827                 }
27828                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
27829                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.function_name, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t), CH_UTF16));
27830                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
27831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
27832                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
27833                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27834                         NDR_PULL_ALLOC(ndr, r->in.status_code);
27835                 }
27836                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
27837                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
27838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
27839                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
27840                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
27841                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
27842                 NDR_PULL_ALLOC(ndr, r->out.needed);
27843                 ZERO_STRUCTP(r->out.needed);
27844                 NDR_PULL_ALLOC(ndr, r->out.status_code);
27845                 *r->out.status_code = *r->in.status_code;
27846         }
27847         if (flags & NDR_OUT) {
27848                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
27849                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27850                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
27851                 }
27852                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
27853                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27854                         NDR_PULL_ALLOC(ndr, r->out.needed);
27855                 }
27856                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27857                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27859                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27860                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27861                         NDR_PULL_ALLOC(ndr, r->out.status_code);
27862                 }
27863                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
27864                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
27865                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
27866                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
27867                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27868                 if (r->out.out_data) {
27869                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
27870                 }
27871         }
27872         return NDR_ERR_SUCCESS;
27873 }
27874
27875 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
27876 {
27877         ndr_print_struct(ndr, name, "spoolss_XcvData");
27878         ndr->depth++;
27879         if (flags & NDR_SET_VALUES) {
27880                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27881         }
27882         if (flags & NDR_IN) {
27883                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
27884                 ndr->depth++;
27885                 ndr_print_ptr(ndr, "handle", r->in.handle);
27886                 ndr->depth++;
27887                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27888                 ndr->depth--;
27889                 ndr_print_string(ndr, "function_name", r->in.function_name);
27890                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
27891                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
27892                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
27893                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
27894                 ndr->depth++;
27895                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
27896                 ndr->depth--;
27897                 ndr->depth--;
27898         }
27899         if (flags & NDR_OUT) {
27900                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
27901                 ndr->depth++;
27902                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
27903                 ndr->depth++;
27904                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
27905                 ndr->depth--;
27906                 ndr_print_ptr(ndr, "needed", r->out.needed);
27907                 ndr->depth++;
27908                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27909                 ndr->depth--;
27910                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
27911                 ndr->depth++;
27912                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
27913                 ndr->depth--;
27914                 ndr_print_WERROR(ndr, "result", r->out.result);
27915                 ndr->depth--;
27916         }
27917         ndr->depth--;
27918 }
27919
27920 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
27921 {
27922         if (flags & NDR_IN) {
27923                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
27924                 if (r->in.servername) {
27925                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
27926                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27927                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
27928                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27929                 }
27930                 if (r->in.info_ctr == NULL) {
27931                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27932                 }
27933                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27934                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
27935         }
27936         if (flags & NDR_OUT) {
27937                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27938         }
27939         return NDR_ERR_SUCCESS;
27940 }
27941
27942 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
27943 {
27944         uint32_t _ptr_servername;
27945         TALLOC_CTX *_mem_save_servername_0;
27946         TALLOC_CTX *_mem_save_info_ctr_0;
27947         if (flags & NDR_IN) {
27948                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
27949                 if (_ptr_servername) {
27950                         NDR_PULL_ALLOC(ndr, r->in.servername);
27951                 } else {
27952                         r->in.servername = NULL;
27953                 }
27954                 if (r->in.servername) {
27955                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
27956                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
27957                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
27958                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
27959                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
27960                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
27961                         }
27962                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
27963                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
27964                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
27965                 }
27966                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27967                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
27968                 }
27969                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27970                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
27971                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27972                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27973                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
27974         }
27975         if (flags & NDR_OUT) {
27976                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27977         }
27978         return NDR_ERR_SUCCESS;
27979 }
27980
27981 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
27982 {
27983         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
27984         ndr->depth++;
27985         if (flags & NDR_SET_VALUES) {
27986                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27987         }
27988         if (flags & NDR_IN) {
27989                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
27990                 ndr->depth++;
27991                 ndr_print_ptr(ndr, "servername", r->in.servername);
27992                 ndr->depth++;
27993                 if (r->in.servername) {
27994                         ndr_print_string(ndr, "servername", r->in.servername);
27995                 }
27996                 ndr->depth--;
27997                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
27998                 ndr->depth++;
27999                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
28000                 ndr->depth--;
28001                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
28002                 ndr->depth--;
28003         }
28004         if (flags & NDR_OUT) {
28005                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
28006                 ndr->depth++;
28007                 ndr_print_WERROR(ndr, "result", r->out.result);
28008                 ndr->depth--;
28009         }
28010         ndr->depth--;
28011 }
28012
28013 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
28014 {
28015         if (flags & NDR_IN) {
28016         }
28017         if (flags & NDR_OUT) {
28018                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28019         }
28020         return NDR_ERR_SUCCESS;
28021 }
28022
28023 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
28024 {
28025         if (flags & NDR_IN) {
28026         }
28027         if (flags & NDR_OUT) {
28028                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28029         }
28030         return NDR_ERR_SUCCESS;
28031 }
28032
28033 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
28034 {
28035         ndr_print_struct(ndr, name, "spoolss_5a");
28036         ndr->depth++;
28037         if (flags & NDR_SET_VALUES) {
28038                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28039         }
28040         if (flags & NDR_IN) {
28041                 ndr_print_struct(ndr, "in", "spoolss_5a");
28042                 ndr->depth++;
28043                 ndr->depth--;
28044         }
28045         if (flags & NDR_OUT) {
28046                 ndr_print_struct(ndr, "out", "spoolss_5a");
28047                 ndr->depth++;
28048                 ndr_print_WERROR(ndr, "result", r->out.result);
28049                 ndr->depth--;
28050         }
28051         ndr->depth--;
28052 }
28053
28054 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
28055 {
28056         if (flags & NDR_IN) {
28057         }
28058         if (flags & NDR_OUT) {
28059                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28060         }
28061         return NDR_ERR_SUCCESS;
28062 }
28063
28064 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
28065 {
28066         if (flags & NDR_IN) {
28067         }
28068         if (flags & NDR_OUT) {
28069                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28070         }
28071         return NDR_ERR_SUCCESS;
28072 }
28073
28074 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
28075 {
28076         ndr_print_struct(ndr, name, "spoolss_5b");
28077         ndr->depth++;
28078         if (flags & NDR_SET_VALUES) {
28079                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28080         }
28081         if (flags & NDR_IN) {
28082                 ndr_print_struct(ndr, "in", "spoolss_5b");
28083                 ndr->depth++;
28084                 ndr->depth--;
28085         }
28086         if (flags & NDR_OUT) {
28087                 ndr_print_struct(ndr, "out", "spoolss_5b");
28088                 ndr->depth++;
28089                 ndr_print_WERROR(ndr, "result", r->out.result);
28090                 ndr->depth--;
28091         }
28092         ndr->depth--;
28093 }
28094
28095 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
28096 {
28097         if (flags & NDR_IN) {
28098         }
28099         if (flags & NDR_OUT) {
28100                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28101         }
28102         return NDR_ERR_SUCCESS;
28103 }
28104
28105 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
28106 {
28107         if (flags & NDR_IN) {
28108         }
28109         if (flags & NDR_OUT) {
28110                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28111         }
28112         return NDR_ERR_SUCCESS;
28113 }
28114
28115 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
28116 {
28117         ndr_print_struct(ndr, name, "spoolss_5c");
28118         ndr->depth++;
28119         if (flags & NDR_SET_VALUES) {
28120                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28121         }
28122         if (flags & NDR_IN) {
28123                 ndr_print_struct(ndr, "in", "spoolss_5c");
28124                 ndr->depth++;
28125                 ndr->depth--;
28126         }
28127         if (flags & NDR_OUT) {
28128                 ndr_print_struct(ndr, "out", "spoolss_5c");
28129                 ndr->depth++;
28130                 ndr_print_WERROR(ndr, "result", r->out.result);
28131                 ndr->depth--;
28132         }
28133         ndr->depth--;
28134 }
28135
28136 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
28137 {
28138         if (flags & NDR_IN) {
28139         }
28140         if (flags & NDR_OUT) {
28141                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28142         }
28143         return NDR_ERR_SUCCESS;
28144 }
28145
28146 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
28147 {
28148         if (flags & NDR_IN) {
28149         }
28150         if (flags & NDR_OUT) {
28151                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28152         }
28153         return NDR_ERR_SUCCESS;
28154 }
28155
28156 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
28157 {
28158         ndr_print_struct(ndr, name, "spoolss_5d");
28159         ndr->depth++;
28160         if (flags & NDR_SET_VALUES) {
28161                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28162         }
28163         if (flags & NDR_IN) {
28164                 ndr_print_struct(ndr, "in", "spoolss_5d");
28165                 ndr->depth++;
28166                 ndr->depth--;
28167         }
28168         if (flags & NDR_OUT) {
28169                 ndr_print_struct(ndr, "out", "spoolss_5d");
28170                 ndr->depth++;
28171                 ndr_print_WERROR(ndr, "result", r->out.result);
28172                 ndr->depth--;
28173         }
28174         ndr->depth--;
28175 }
28176
28177 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
28178 {
28179         if (flags & NDR_IN) {
28180         }
28181         if (flags & NDR_OUT) {
28182                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28183         }
28184         return NDR_ERR_SUCCESS;
28185 }
28186
28187 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
28188 {
28189         if (flags & NDR_IN) {
28190         }
28191         if (flags & NDR_OUT) {
28192                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28193         }
28194         return NDR_ERR_SUCCESS;
28195 }
28196
28197 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
28198 {
28199         ndr_print_struct(ndr, name, "spoolss_5e");
28200         ndr->depth++;
28201         if (flags & NDR_SET_VALUES) {
28202                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28203         }
28204         if (flags & NDR_IN) {
28205                 ndr_print_struct(ndr, "in", "spoolss_5e");
28206                 ndr->depth++;
28207                 ndr->depth--;
28208         }
28209         if (flags & NDR_OUT) {
28210                 ndr_print_struct(ndr, "out", "spoolss_5e");
28211                 ndr->depth++;
28212                 ndr_print_WERROR(ndr, "result", r->out.result);
28213                 ndr->depth--;
28214         }
28215         ndr->depth--;
28216 }
28217
28218 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
28219 {
28220         if (flags & NDR_IN) {
28221         }
28222         if (flags & NDR_OUT) {
28223                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28224         }
28225         return NDR_ERR_SUCCESS;
28226 }
28227
28228 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
28229 {
28230         if (flags & NDR_IN) {
28231         }
28232         if (flags & NDR_OUT) {
28233                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28234         }
28235         return NDR_ERR_SUCCESS;
28236 }
28237
28238 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
28239 {
28240         ndr_print_struct(ndr, name, "spoolss_5f");
28241         ndr->depth++;
28242         if (flags & NDR_SET_VALUES) {
28243                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28244         }
28245         if (flags & NDR_IN) {
28246                 ndr_print_struct(ndr, "in", "spoolss_5f");
28247                 ndr->depth++;
28248                 ndr->depth--;
28249         }
28250         if (flags & NDR_OUT) {
28251                 ndr_print_struct(ndr, "out", "spoolss_5f");
28252                 ndr->depth++;
28253                 ndr_print_WERROR(ndr, "result", r->out.result);
28254                 ndr->depth--;
28255         }
28256         ndr->depth--;
28257 }
28258
28259 static const struct ndr_interface_call spoolss_calls[] = {
28260         {
28261                 "spoolss_EnumPrinters",
28262                 sizeof(struct spoolss_EnumPrinters),
28263                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
28264                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
28265                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
28266                 false,
28267         },
28268         {
28269                 "spoolss_OpenPrinter",
28270                 sizeof(struct spoolss_OpenPrinter),
28271                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
28272                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
28273                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
28274                 false,
28275         },
28276         {
28277                 "spoolss_SetJob",
28278                 sizeof(struct spoolss_SetJob),
28279                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
28280                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
28281                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
28282                 false,
28283         },
28284         {
28285                 "spoolss_GetJob",
28286                 sizeof(struct spoolss_GetJob),
28287                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
28288                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
28289                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
28290                 false,
28291         },
28292         {
28293                 "spoolss_EnumJobs",
28294                 sizeof(struct spoolss_EnumJobs),
28295                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
28296                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
28297                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
28298                 false,
28299         },
28300         {
28301                 "spoolss_AddPrinter",
28302                 sizeof(struct spoolss_AddPrinter),
28303                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
28304                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
28305                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
28306                 false,
28307         },
28308         {
28309                 "spoolss_DeletePrinter",
28310                 sizeof(struct spoolss_DeletePrinter),
28311                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
28312                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
28313                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
28314                 false,
28315         },
28316         {
28317                 "spoolss_SetPrinter",
28318                 sizeof(struct spoolss_SetPrinter),
28319                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
28320                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
28321                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
28322                 false,
28323         },
28324         {
28325                 "spoolss_GetPrinter",
28326                 sizeof(struct spoolss_GetPrinter),
28327                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
28328                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
28329                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
28330                 false,
28331         },
28332         {
28333                 "spoolss_AddPrinterDriver",
28334                 sizeof(struct spoolss_AddPrinterDriver),
28335                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
28336                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
28337                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
28338                 false,
28339         },
28340         {
28341                 "spoolss_EnumPrinterDrivers",
28342                 sizeof(struct spoolss_EnumPrinterDrivers),
28343                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
28344                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
28345                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
28346                 false,
28347         },
28348         {
28349                 "spoolss_GetPrinterDriver",
28350                 sizeof(struct spoolss_GetPrinterDriver),
28351                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
28352                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
28353                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
28354                 false,
28355         },
28356         {
28357                 "spoolss_GetPrinterDriverDirectory",
28358                 sizeof(struct spoolss_GetPrinterDriverDirectory),
28359                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
28360                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
28361                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
28362                 false,
28363         },
28364         {
28365                 "spoolss_DeletePrinterDriver",
28366                 sizeof(struct spoolss_DeletePrinterDriver),
28367                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
28368                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
28369                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
28370                 false,
28371         },
28372         {
28373                 "spoolss_AddPrintProcessor",
28374                 sizeof(struct spoolss_AddPrintProcessor),
28375                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
28376                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
28377                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
28378                 false,
28379         },
28380         {
28381                 "spoolss_EnumPrintProcessors",
28382                 sizeof(struct spoolss_EnumPrintProcessors),
28383                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
28384                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
28385                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
28386                 false,
28387         },
28388         {
28389                 "spoolss_GetPrintProcessorDirectory",
28390                 sizeof(struct spoolss_GetPrintProcessorDirectory),
28391                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
28392                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
28393                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
28394                 false,
28395         },
28396         {
28397                 "spoolss_StartDocPrinter",
28398                 sizeof(struct spoolss_StartDocPrinter),
28399                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
28400                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
28401                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
28402                 false,
28403         },
28404         {
28405                 "spoolss_StartPagePrinter",
28406                 sizeof(struct spoolss_StartPagePrinter),
28407                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
28408                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
28409                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
28410                 false,
28411         },
28412         {
28413                 "spoolss_WritePrinter",
28414                 sizeof(struct spoolss_WritePrinter),
28415                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
28416                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
28417                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
28418                 false,
28419         },
28420         {
28421                 "spoolss_EndPagePrinter",
28422                 sizeof(struct spoolss_EndPagePrinter),
28423                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
28424                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
28425                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
28426                 false,
28427         },
28428         {
28429                 "spoolss_AbortPrinter",
28430                 sizeof(struct spoolss_AbortPrinter),
28431                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
28432                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
28433                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
28434                 false,
28435         },
28436         {
28437                 "spoolss_ReadPrinter",
28438                 sizeof(struct spoolss_ReadPrinter),
28439                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
28440                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
28441                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
28442                 false,
28443         },
28444         {
28445                 "spoolss_EndDocPrinter",
28446                 sizeof(struct spoolss_EndDocPrinter),
28447                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
28448                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
28449                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
28450                 false,
28451         },
28452         {
28453                 "spoolss_AddJob",
28454                 sizeof(struct spoolss_AddJob),
28455                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
28456                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
28457                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
28458                 false,
28459         },
28460         {
28461                 "spoolss_ScheduleJob",
28462                 sizeof(struct spoolss_ScheduleJob),
28463                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
28464                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
28465                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
28466                 false,
28467         },
28468         {
28469                 "spoolss_GetPrinterData",
28470                 sizeof(struct spoolss_GetPrinterData),
28471                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
28472                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
28473                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
28474                 false,
28475         },
28476         {
28477                 "spoolss_SetPrinterData",
28478                 sizeof(struct spoolss_SetPrinterData),
28479                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
28480                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
28481                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
28482                 false,
28483         },
28484         {
28485                 "spoolss_WaitForPrinterChange",
28486                 sizeof(struct spoolss_WaitForPrinterChange),
28487                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
28488                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
28489                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
28490                 false,
28491         },
28492         {
28493                 "spoolss_ClosePrinter",
28494                 sizeof(struct spoolss_ClosePrinter),
28495                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
28496                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
28497                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
28498                 false,
28499         },
28500         {
28501                 "spoolss_AddForm",
28502                 sizeof(struct spoolss_AddForm),
28503                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
28504                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
28505                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
28506                 false,
28507         },
28508         {
28509                 "spoolss_DeleteForm",
28510                 sizeof(struct spoolss_DeleteForm),
28511                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
28512                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
28513                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
28514                 false,
28515         },
28516         {
28517                 "spoolss_GetForm",
28518                 sizeof(struct spoolss_GetForm),
28519                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
28520                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
28521                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
28522                 false,
28523         },
28524         {
28525                 "spoolss_SetForm",
28526                 sizeof(struct spoolss_SetForm),
28527                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
28528                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
28529                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
28530                 false,
28531         },
28532         {
28533                 "spoolss_EnumForms",
28534                 sizeof(struct spoolss_EnumForms),
28535                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
28536                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
28537                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
28538                 false,
28539         },
28540         {
28541                 "spoolss_EnumPorts",
28542                 sizeof(struct spoolss_EnumPorts),
28543                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
28544                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
28545                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
28546                 false,
28547         },
28548         {
28549                 "spoolss_EnumMonitors",
28550                 sizeof(struct spoolss_EnumMonitors),
28551                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
28552                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
28553                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
28554                 false,
28555         },
28556         {
28557                 "spoolss_AddPort",
28558                 sizeof(struct spoolss_AddPort),
28559                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
28560                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
28561                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
28562                 false,
28563         },
28564         {
28565                 "spoolss_ConfigurePort",
28566                 sizeof(struct spoolss_ConfigurePort),
28567                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
28568                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
28569                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
28570                 false,
28571         },
28572         {
28573                 "spoolss_DeletePort",
28574                 sizeof(struct spoolss_DeletePort),
28575                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
28576                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
28577                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
28578                 false,
28579         },
28580         {
28581                 "spoolss_CreatePrinterIC",
28582                 sizeof(struct spoolss_CreatePrinterIC),
28583                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
28584                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
28585                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
28586                 false,
28587         },
28588         {
28589                 "spoolss_PlayGDIScriptOnPrinterIC",
28590                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
28591                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
28592                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
28593                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
28594                 false,
28595         },
28596         {
28597                 "spoolss_DeletePrinterIC",
28598                 sizeof(struct spoolss_DeletePrinterIC),
28599                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
28600                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
28601                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
28602                 false,
28603         },
28604         {
28605                 "spoolss_AddPrinterConnection",
28606                 sizeof(struct spoolss_AddPrinterConnection),
28607                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
28608                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
28609                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
28610                 false,
28611         },
28612         {
28613                 "spoolss_DeletePrinterConnection",
28614                 sizeof(struct spoolss_DeletePrinterConnection),
28615                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
28616                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
28617                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
28618                 false,
28619         },
28620         {
28621                 "spoolss_PrinterMessageBox",
28622                 sizeof(struct spoolss_PrinterMessageBox),
28623                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
28624                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
28625                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
28626                 false,
28627         },
28628         {
28629                 "spoolss_AddMonitor",
28630                 sizeof(struct spoolss_AddMonitor),
28631                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
28632                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
28633                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
28634                 false,
28635         },
28636         {
28637                 "spoolss_DeleteMonitor",
28638                 sizeof(struct spoolss_DeleteMonitor),
28639                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
28640                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
28641                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
28642                 false,
28643         },
28644         {
28645                 "spoolss_DeletePrintProcessor",
28646                 sizeof(struct spoolss_DeletePrintProcessor),
28647                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
28648                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
28649                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
28650                 false,
28651         },
28652         {
28653                 "spoolss_AddPrintProvidor",
28654                 sizeof(struct spoolss_AddPrintProvidor),
28655                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
28656                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
28657                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
28658                 false,
28659         },
28660         {
28661                 "spoolss_DeletePrintProvidor",
28662                 sizeof(struct spoolss_DeletePrintProvidor),
28663                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
28664                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
28665                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
28666                 false,
28667         },
28668         {
28669                 "spoolss_EnumPrintProcDataTypes",
28670                 sizeof(struct spoolss_EnumPrintProcDataTypes),
28671                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
28672                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
28673                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
28674                 false,
28675         },
28676         {
28677                 "spoolss_ResetPrinter",
28678                 sizeof(struct spoolss_ResetPrinter),
28679                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
28680                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
28681                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
28682                 false,
28683         },
28684         {
28685                 "spoolss_GetPrinterDriver2",
28686                 sizeof(struct spoolss_GetPrinterDriver2),
28687                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
28688                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
28689                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
28690                 false,
28691         },
28692         {
28693                 "spoolss_FindFirstPrinterChangeNotification",
28694                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
28695                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
28696                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
28697                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
28698                 false,
28699         },
28700         {
28701                 "spoolss_FindNextPrinterChangeNotification",
28702                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
28703                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
28704                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
28705                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
28706                 false,
28707         },
28708         {
28709                 "spoolss_FindClosePrinterNotify",
28710                 sizeof(struct spoolss_FindClosePrinterNotify),
28711                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
28712                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
28713                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
28714                 false,
28715         },
28716         {
28717                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
28718                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
28719                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
28720                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
28721                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
28722                 false,
28723         },
28724         {
28725                 "spoolss_ReplyOpenPrinter",
28726                 sizeof(struct spoolss_ReplyOpenPrinter),
28727                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
28728                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
28729                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
28730                 false,
28731         },
28732         {
28733                 "spoolss_RouterReplyPrinter",
28734                 sizeof(struct spoolss_RouterReplyPrinter),
28735                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
28736                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
28737                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
28738                 false,
28739         },
28740         {
28741                 "spoolss_ReplyClosePrinter",
28742                 sizeof(struct spoolss_ReplyClosePrinter),
28743                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
28744                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
28745                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
28746                 false,
28747         },
28748         {
28749                 "spoolss_AddPortEx",
28750                 sizeof(struct spoolss_AddPortEx),
28751                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
28752                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
28753                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
28754                 false,
28755         },
28756         {
28757                 "spoolss_RouterFindFirstPrinterChangeNotification",
28758                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
28759                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
28760                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
28761                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
28762                 false,
28763         },
28764         {
28765                 "spoolss_SpoolerInit",
28766                 sizeof(struct spoolss_SpoolerInit),
28767                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
28768                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
28769                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
28770                 false,
28771         },
28772         {
28773                 "spoolss_ResetPrinterEx",
28774                 sizeof(struct spoolss_ResetPrinterEx),
28775                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
28776                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
28777                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
28778                 false,
28779         },
28780         {
28781                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
28782                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
28783                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
28784                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
28785                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
28786                 false,
28787         },
28788         {
28789                 "spoolss_RouterReplyPrinterEx",
28790                 sizeof(struct spoolss_RouterReplyPrinterEx),
28791                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
28792                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
28793                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
28794                 false,
28795         },
28796         {
28797                 "spoolss_RouterRefreshPrinterChangeNotify",
28798                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
28799                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
28800                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
28801                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
28802                 false,
28803         },
28804         {
28805                 "spoolss_44",
28806                 sizeof(struct spoolss_44),
28807                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
28808                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
28809                 (ndr_print_function_t) ndr_print_spoolss_44,
28810                 false,
28811         },
28812         {
28813                 "spoolss_OpenPrinterEx",
28814                 sizeof(struct spoolss_OpenPrinterEx),
28815                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
28816                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
28817                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
28818                 false,
28819         },
28820         {
28821                 "spoolss_AddPrinterEx",
28822                 sizeof(struct spoolss_AddPrinterEx),
28823                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
28824                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
28825                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
28826                 false,
28827         },
28828         {
28829                 "spoolss_47",
28830                 sizeof(struct spoolss_47),
28831                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
28832                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
28833                 (ndr_print_function_t) ndr_print_spoolss_47,
28834                 false,
28835         },
28836         {
28837                 "spoolss_EnumPrinterData",
28838                 sizeof(struct spoolss_EnumPrinterData),
28839                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
28840                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
28841                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
28842                 false,
28843         },
28844         {
28845                 "spoolss_DeletePrinterData",
28846                 sizeof(struct spoolss_DeletePrinterData),
28847                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
28848                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
28849                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
28850                 false,
28851         },
28852         {
28853                 "spoolss_4a",
28854                 sizeof(struct spoolss_4a),
28855                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
28856                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
28857                 (ndr_print_function_t) ndr_print_spoolss_4a,
28858                 false,
28859         },
28860         {
28861                 "spoolss_4b",
28862                 sizeof(struct spoolss_4b),
28863                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
28864                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
28865                 (ndr_print_function_t) ndr_print_spoolss_4b,
28866                 false,
28867         },
28868         {
28869                 "spoolss_4c",
28870                 sizeof(struct spoolss_4c),
28871                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
28872                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
28873                 (ndr_print_function_t) ndr_print_spoolss_4c,
28874                 false,
28875         },
28876         {
28877                 "spoolss_SetPrinterDataEx",
28878                 sizeof(struct spoolss_SetPrinterDataEx),
28879                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
28880                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
28881                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
28882                 false,
28883         },
28884         {
28885                 "spoolss_GetPrinterDataEx",
28886                 sizeof(struct spoolss_GetPrinterDataEx),
28887                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
28888                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
28889                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
28890                 false,
28891         },
28892         {
28893                 "spoolss_EnumPrinterDataEx",
28894                 sizeof(struct spoolss_EnumPrinterDataEx),
28895                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
28896                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
28897                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
28898                 false,
28899         },
28900         {
28901                 "spoolss_EnumPrinterKey",
28902                 sizeof(struct spoolss_EnumPrinterKey),
28903                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
28904                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
28905                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
28906                 false,
28907         },
28908         {
28909                 "spoolss_DeletePrinterDataEx",
28910                 sizeof(struct spoolss_DeletePrinterDataEx),
28911                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
28912                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
28913                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
28914                 false,
28915         },
28916         {
28917                 "spoolss_DeletePrinterKey",
28918                 sizeof(struct spoolss_DeletePrinterKey),
28919                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
28920                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
28921                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
28922                 false,
28923         },
28924         {
28925                 "spoolss_53",
28926                 sizeof(struct spoolss_53),
28927                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
28928                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
28929                 (ndr_print_function_t) ndr_print_spoolss_53,
28930                 false,
28931         },
28932         {
28933                 "spoolss_DeletePrinterDriverEx",
28934                 sizeof(struct spoolss_DeletePrinterDriverEx),
28935                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
28936                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
28937                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
28938                 false,
28939         },
28940         {
28941                 "spoolss_55",
28942                 sizeof(struct spoolss_55),
28943                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
28944                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
28945                 (ndr_print_function_t) ndr_print_spoolss_55,
28946                 false,
28947         },
28948         {
28949                 "spoolss_56",
28950                 sizeof(struct spoolss_56),
28951                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
28952                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
28953                 (ndr_print_function_t) ndr_print_spoolss_56,
28954                 false,
28955         },
28956         {
28957                 "spoolss_57",
28958                 sizeof(struct spoolss_57),
28959                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
28960                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
28961                 (ndr_print_function_t) ndr_print_spoolss_57,
28962                 false,
28963         },
28964         {
28965                 "spoolss_XcvData",
28966                 sizeof(struct spoolss_XcvData),
28967                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
28968                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
28969                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
28970                 false,
28971         },
28972         {
28973                 "spoolss_AddPrinterDriverEx",
28974                 sizeof(struct spoolss_AddPrinterDriverEx),
28975                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
28976                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
28977                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
28978                 false,
28979         },
28980         {
28981                 "spoolss_5a",
28982                 sizeof(struct spoolss_5a),
28983                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
28984                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
28985                 (ndr_print_function_t) ndr_print_spoolss_5a,
28986                 false,
28987         },
28988         {
28989                 "spoolss_5b",
28990                 sizeof(struct spoolss_5b),
28991                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
28992                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
28993                 (ndr_print_function_t) ndr_print_spoolss_5b,
28994                 false,
28995         },
28996         {
28997                 "spoolss_5c",
28998                 sizeof(struct spoolss_5c),
28999                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
29000                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
29001                 (ndr_print_function_t) ndr_print_spoolss_5c,
29002                 false,
29003         },
29004         {
29005                 "spoolss_5d",
29006                 sizeof(struct spoolss_5d),
29007                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
29008                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
29009                 (ndr_print_function_t) ndr_print_spoolss_5d,
29010                 false,
29011         },
29012         {
29013                 "spoolss_5e",
29014                 sizeof(struct spoolss_5e),
29015                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
29016                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
29017                 (ndr_print_function_t) ndr_print_spoolss_5e,
29018                 false,
29019         },
29020         {
29021                 "spoolss_5f",
29022                 sizeof(struct spoolss_5f),
29023                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
29024                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
29025                 (ndr_print_function_t) ndr_print_spoolss_5f,
29026                 false,
29027         },
29028         { NULL, 0, NULL, NULL, NULL, false }
29029 };
29030
29031 static const char * const spoolss_endpoint_strings[] = {
29032         "ncacn_np:[\\pipe\\spoolss]",
29033 };
29034
29035 static const struct ndr_interface_string_array spoolss_endpoints = {
29036         .count  = 1,
29037         .names  = spoolss_endpoint_strings
29038 };
29039
29040 static const char * const spoolss_authservice_strings[] = {
29041         "host",
29042 };
29043
29044 static const struct ndr_interface_string_array spoolss_authservices = {
29045         .count  = 1,
29046         .names  = spoolss_authservice_strings
29047 };
29048
29049
29050 const struct ndr_interface_table ndr_table_spoolss = {
29051         .name           = "spoolss",
29052         .syntax_id      = {
29053                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
29054                 NDR_SPOOLSS_VERSION
29055         },
29056         .helpstring     = NDR_SPOOLSS_HELPSTRING,
29057         .num_calls      = 96,
29058         .calls          = spoolss_calls,
29059         .endpoints      = &spoolss_endpoints,
29060         .authservices   = &spoolss_authservices
29061 };
29062