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 static 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 static 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(ndr, r->printername));
 357                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 358                         }
 359                         ndr->flags = _flags_save_string;
 360                 }
 361                 {
 362                         uint32_t _flags_save_string = ndr->flags;
 363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 364                         if (r->servername) {
 365                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 366                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 367                         }
 368                         ndr->flags = _flags_save_string;
 369                 }
 370         }
 371         return NDR_ERR_SUCCESS;
 372 }
 373
 374 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 375 {
 376         uint32_t _ptr_printername;
 377         TALLOC_CTX *_mem_save_printername_0;
 378         uint32_t _ptr_servername;
 379         TALLOC_CTX *_mem_save_servername_0;
 380         if (ndr_flags & NDR_SCALARS) {
 381                 NDR_CHECK(ndr_pull_align(ndr, 4));
 382                 {
 383                         uint32_t _flags_save_string = ndr->flags;
 384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 385                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 386                         if (_ptr_printername) {
 387                                 NDR_PULL_ALLOC(ndr, r->printername);
 388                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 389                         } else {
 390                                 r->printername = NULL;
 391                         }
 392                         ndr->flags = _flags_save_string;
 393                 }
 394                 {
 395                         uint32_t _flags_save_string = ndr->flags;
 396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 397                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 398                         if (_ptr_servername) {
 399                                 NDR_PULL_ALLOC(ndr, r->servername);
 400                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 401                         } else {
 402                                 r->servername = NULL;
 403                         }
 404                         ndr->flags = _flags_save_string;
 405                 }
 406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 407                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 408                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 409                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 419                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 421                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 424                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 425                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 428                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 429                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 433         }
 434         if (ndr_flags & NDR_BUFFERS) {
 435                 {
 436                         uint32_t _flags_save_string = ndr->flags;
 437                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 438                         if (r->printername) {
 439                                 uint32_t _relative_save_offset;
 440                                 _relative_save_offset = ndr->offset;
 441                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 442                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 443                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 444                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 445                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 446                                 ndr->offset = _relative_save_offset;
 447                         }
 448                         ndr->flags = _flags_save_string;
 449                 }
 450                 {
 451                         uint32_t _flags_save_string = ndr->flags;
 452                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 453                         if (r->servername) {
 454                                 uint32_t _relative_save_offset;
 455                                 _relative_save_offset = ndr->offset;
 456                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 457                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 458                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 459                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 460                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 461                                 ndr->offset = _relative_save_offset;
 462                         }
 463                         ndr->flags = _flags_save_string;
 464                 }
 465         }
 466         return NDR_ERR_SUCCESS;
 467 }
 468
 469 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 470 {
 471         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 472         ndr->depth++;
 473         ndr_print_ptr(ndr, "printername", r->printername);
 474         ndr->depth++;
 475         if (r->printername) {
 476                 ndr_print_string(ndr, "printername", r->printername);
 477         }
 478         ndr->depth--;
 479         ndr_print_ptr(ndr, "servername", r->servername);
 480         ndr->depth++;
 481         if (r->servername) {
 482                 ndr_print_string(ndr, "servername", r->servername);
 483         }
 484         ndr->depth--;
 485         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 486         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 487         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 488         ndr_print_spoolss_Time(ndr, "time", &r->time);
 489         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 490         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 491         ndr_print_uint32(ndr, "version", r->version);
 492         ndr_print_uint32(ndr, "free_build", r->free_build);
 493         ndr_print_uint32(ndr, "spooling", r->spooling);
 494         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 495         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 496         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 497         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 498         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 499         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 500         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 501         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 502         ndr_print_uint32(ndr, "change_id", r->change_id);
 503         ndr_print_WERROR(ndr, "last_error", r->last_error);
 504         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 505         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 506         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 507         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 508         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 509         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 510         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 511         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 512         ndr->depth--;
 513 }
 514
 515 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo0(const struct spoolss_PrinterInfo0 *r, struct smb_iconv_convenience *ic, int flags)
 516 {
 517         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo0, ic);
 518 }
 519
 520 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 521 {
 522         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 523         return NDR_ERR_SUCCESS;
 524 }
 525
 526 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 527 {
 528         uint32_t v;
 529         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 530         *r = v;
 531         return NDR_ERR_SUCCESS;
 532 }
 533
 534 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 535 {
 536         ndr_print_uint32(ndr, name, r);
 537         ndr->depth++;
 538         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 539         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 540         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 541         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 542         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 543         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 544         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 545         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 546         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 561         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 562         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 563         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 564         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 565         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 566         ndr->depth--;
 567 }
 568
 569 static enum ndr_err_code ndr_push_spoolss_DeviceModeSpecVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion r)
 570 {
 571         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 572         return NDR_ERR_SUCCESS;
 573 }
 574
 575 static enum ndr_err_code ndr_pull_spoolss_DeviceModeSpecVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion *r)
 576 {
 577         uint16_t v;
 578         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 579         *r = v;
 580         return NDR_ERR_SUCCESS;
 581 }
 582
 583 _PUBLIC_ void ndr_print_spoolss_DeviceModeSpecVersion(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeSpecVersion r)
 584 {
 585         const char *val = NULL;
 586
 587         switch (r) {
 588                 case DMSPEC_NT3: val = "DMSPEC_NT3"; break;
 589                 case DMSPEC_WIN95_98_ME: val = "DMSPEC_WIN95_98_ME"; break;
 590                 case DMSPEC_NT4_AND_ABOVE: val = "DMSPEC_NT4_AND_ABOVE"; break;
 591         }
 592         ndr_print_enum(ndr, name, "ENUM", val, r);
 593 }
 594
 595 static enum ndr_err_code ndr_push_spoolss_DeviceModeOrientation(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation r)
 596 {
 597         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 598         return NDR_ERR_SUCCESS;
 599 }
 600
 601 static enum ndr_err_code ndr_pull_spoolss_DeviceModeOrientation(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation *r)
 602 {
 603         uint16_t v;
 604         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 605         *r = v;
 606         return NDR_ERR_SUCCESS;
 607 }
 608
 609 _PUBLIC_ void ndr_print_spoolss_DeviceModeOrientation(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeOrientation r)
 610 {
 611         const char *val = NULL;
 612
 613         switch (r) {
 614                 case DMORIENT_PORTRAIT: val = "DMORIENT_PORTRAIT"; break;
 615                 case DMORIENT_LANDSCAPE: val = "DMORIENT_LANDSCAPE"; break;
 616         }
 617         ndr_print_enum(ndr, name, "ENUM", val, r);
 618 }
 619
 620 static enum ndr_err_code ndr_push_spoolss_DeviceModePaperSize(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize r)
 621 {
 622         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 623         return NDR_ERR_SUCCESS;
 624 }
 625
 626 static enum ndr_err_code ndr_pull_spoolss_DeviceModePaperSize(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize *r)
 627 {
 628         uint16_t v;
 629         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 630         *r = v;
 631         return NDR_ERR_SUCCESS;
 632 }
 633
 634 _PUBLIC_ void ndr_print_spoolss_DeviceModePaperSize(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePaperSize r)
 635 {
 636         const char *val = NULL;
 637
 638         switch (r) {
 639                 case DMPAPER_LETTER: val = "DMPAPER_LETTER"; break;
 640                 case DMPAPER_LETTERSMALL: val = "DMPAPER_LETTERSMALL"; break;
 641                 case DMPAPER_TABLOID: val = "DMPAPER_TABLOID"; break;
 642                 case DMPAPER_LEDGER: val = "DMPAPER_LEDGER"; break;
 643                 case DMPAPER_LEGAL: val = "DMPAPER_LEGAL"; break;
 644                 case DMPAPER_STATEMENT: val = "DMPAPER_STATEMENT"; break;
 645                 case DMPAPER_EXECUTIVE: val = "DMPAPER_EXECUTIVE"; break;
 646                 case DMPAPER_A3: val = "DMPAPER_A3"; break;
 647                 case DMPAPER_A4: val = "DMPAPER_A4"; break;
 648                 case DMPAPER_A4SMALL: val = "DMPAPER_A4SMALL"; break;
 649                 case DMPAPER_A5: val = "DMPAPER_A5"; break;
 650                 case DMPAPER_B4: val = "DMPAPER_B4"; break;
 651                 case DMPAPER_B5: val = "DMPAPER_B5"; break;
 652                 case DMPAPER_FOLIO: val = "DMPAPER_FOLIO"; break;
 653                 case DMPAPER_QUARTO: val = "DMPAPER_QUARTO"; break;
 654                 case DMPAPER_10X14: val = "DMPAPER_10X14"; break;
 655                 case DMPAPER_11X17: val = "DMPAPER_11X17"; break;
 656                 case DMPAPER_NOTE: val = "DMPAPER_NOTE"; break;
 657                 case DMPAPER_ENV_9: val = "DMPAPER_ENV_9"; break;
 658                 case DMPAPER_ENV_10: val = "DMPAPER_ENV_10"; break;
 659                 case DMPAPER_ENV_11: val = "DMPAPER_ENV_11"; break;
 660                 case DMPAPER_ENV_12: val = "DMPAPER_ENV_12"; break;
 661                 case DMPAPER_ENV_14: val = "DMPAPER_ENV_14"; break;
 662                 case DMPAPER_CSHEET: val = "DMPAPER_CSHEET"; break;
 663                 case DMPAPER_DSHEET: val = "DMPAPER_DSHEET"; break;
 664                 case DMPAPER_ESHEET: val = "DMPAPER_ESHEET"; break;
 665                 case DMPAPER_ENV_DL: val = "DMPAPER_ENV_DL"; break;
 666                 case DMPAPER_ENV_C5: val = "DMPAPER_ENV_C5"; break;
 667                 case DMPAPER_ENV_C3: val = "DMPAPER_ENV_C3"; break;
 668                 case DMPAPER_ENV_C4: val = "DMPAPER_ENV_C4"; break;
 669                 case DMPAPER_ENV_C6: val = "DMPAPER_ENV_C6"; break;
 670                 case DMPAPER_ENV_C65: val = "DMPAPER_ENV_C65"; break;
 671                 case DMPAPER_ENV_B4: val = "DMPAPER_ENV_B4"; break;
 672                 case DMPAPER_ENV_B5: val = "DMPAPER_ENV_B5"; break;
 673                 case DMPAPER_ENV_B6: val = "DMPAPER_ENV_B6"; break;
 674                 case DMPAPER_ENV_ITALY: val = "DMPAPER_ENV_ITALY"; break;
 675                 case DMPAPER_ENV_MONARCH: val = "DMPAPER_ENV_MONARCH"; break;
 676                 case DMPAPER_ENV_PERSONAL: val = "DMPAPER_ENV_PERSONAL"; break;
 677                 case DMPAPER_FANFOLD_US: val = "DMPAPER_FANFOLD_US"; break;
 678                 case DMPAPER_FANFOLD_STD_GERMAN: val = "DMPAPER_FANFOLD_STD_GERMAN"; break;
 679                 case DMPAPER_FANFOLD_LGL_GERMAN: val = "DMPAPER_FANFOLD_LGL_GERMAN"; break;
 680                 case DMPAPER_DBL_JAPANESE_POSTCARD: val = "DMPAPER_DBL_JAPANESE_POSTCARD"; break;
 681                 case DMPAPER_A6: val = "DMPAPER_A6"; break;
 682                 case DMPAPER_JENV_KAKU2: val = "DMPAPER_JENV_KAKU2"; break;
 683                 case DMPAPER_JENV_KAKU3: val = "DMPAPER_JENV_KAKU3"; break;
 684                 case DMPAPER_JENV_CHOU3: val = "DMPAPER_JENV_CHOU3"; break;
 685                 case DMPAPER_JENV_CHOU4: val = "DMPAPER_JENV_CHOU4"; break;
 686                 case DMPAPER_LETTER_ROTATED: val = "DMPAPER_LETTER_ROTATED"; break;
 687                 case DMPAPER_A3_ROTATED: val = "DMPAPER_A3_ROTATED"; break;
 688                 case DMPAPER_A4_ROTATED: val = "DMPAPER_A4_ROTATED"; break;
 689                 case DMPAPER_A5_ROTATED: val = "DMPAPER_A5_ROTATED"; break;
 690                 case DMPAPER_B4_JIS_ROTATED: val = "DMPAPER_B4_JIS_ROTATED"; break;
 691                 case DMPAPER_B5_JIS_ROTATED: val = "DMPAPER_B5_JIS_ROTATED"; break;
 692                 case DMPAPER_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_JAPANESE_POSTCARD_ROTATED"; break;
 693                 case DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED"; break;
 694                 case DMPAPER_A6_ROTATED: val = "DMPAPER_A6_ROTATED"; break;
 695                 case DMPAPER_JENV_KAKU2_ROTATED: val = "DMPAPER_JENV_KAKU2_ROTATED"; break;
 696                 case DMPAPER_JENV_KAKU3_ROTATED: val = "DMPAPER_JENV_KAKU3_ROTATED"; break;
 697                 case DMPAPER_JENV_CHOU3_ROTATED: val = "DMPAPER_JENV_CHOU3_ROTATED"; break;
 698                 case DMPAPER_JENV_CHOU4_ROTATED: val = "DMPAPER_JENV_CHOU4_ROTATED"; break;
 699                 case DMPAPER_B6_JIS: val = "DMPAPER_B6_JIS"; break;
 700                 case DMPAPER_B6_JIS_ROTATED: val = "DMPAPER_B6_JIS_ROTATED"; break;
 701                 case DMPAPER_12X11: val = "DMPAPER_12X11"; break;
 702                 case DMPAPER_JENV_YOU4: val = "DMPAPER_JENV_YOU4"; break;
 703                 case DMPAPER_JENV_YOU4_ROTATED: val = "DMPAPER_JENV_YOU4_ROTATED"; break;
 704                 case DMPAPER_P16K: val = "DMPAPER_P16K"; break;
 705                 case DMPAPER_P32K: val = "DMPAPER_P32K"; break;
 706                 case DMPAPER_P32KBIG: val = "DMPAPER_P32KBIG"; break;
 707                 case DMPAPER_PENV_1: val = "DMPAPER_PENV_1"; break;
 708                 case DMPAPER_PENV_2: val = "DMPAPER_PENV_2"; break;
 709                 case DMPAPER_PENV_3: val = "DMPAPER_PENV_3"; break;
 710                 case DMPAPER_PENV_4: val = "DMPAPER_PENV_4"; break;
 711                 case DMPAPER_PENV_5: val = "DMPAPER_PENV_5"; break;
 712                 case DMPAPER_PENV_6: val = "DMPAPER_PENV_6"; break;
 713                 case DMPAPER_PENV_7: val = "DMPAPER_PENV_7"; break;
 714                 case DMPAPER_PENV_8: val = "DMPAPER_PENV_8"; break;
 715                 case DMPAPER_PENV_9: val = "DMPAPER_PENV_9"; break;
 716                 case DMPAPER_PENV_10: val = "DMPAPER_PENV_10"; break;
 717                 case DMPAPER_P16K_ROTATED: val = "DMPAPER_P16K_ROTATED"; break;
 718                 case DMPAPER_P32K_ROTATED: val = "DMPAPER_P32K_ROTATED"; break;
 719                 case DMPAPER_P32KBIG_ROTATED: val = "DMPAPER_P32KBIG_ROTATED"; break;
 720                 case DMPAPER_PENV_1_ROTATED: val = "DMPAPER_PENV_1_ROTATED"; break;
 721                 case DMPAPER_PENV_2_ROTATED: val = "DMPAPER_PENV_2_ROTATED"; break;
 722                 case DMPAPER_PENV_3_ROTATED: val = "DMPAPER_PENV_3_ROTATED"; break;
 723                 case DMPAPER_PENV_4_ROTATED: val = "DMPAPER_PENV_4_ROTATED"; break;
 724                 case DMPAPER_PENV_5_ROTATED: val = "DMPAPER_PENV_5_ROTATED"; break;
 725                 case DMPAPER_PENV_6_ROTATED: val = "DMPAPER_PENV_6_ROTATED"; break;
 726                 case DMPAPER_PENV_7_ROTATED: val = "DMPAPER_PENV_7_ROTATED"; break;
 727                 case DMPAPER_PENV_8_ROTATED: val = "DMPAPER_PENV_8_ROTATED"; break;
 728                 case DMPAPER_PENV_9_ROTATED: val = "DMPAPER_PENV_9_ROTATED"; break;
 729                 case DMPAPER_PENV_10_ROTATED: val = "DMPAPER_PENV_10_ROTATED"; break;
 730         }
 731         ndr_print_enum(ndr, name, "ENUM", val, r);
 732 }
 733
 734 static enum ndr_err_code ndr_push_spoolss_DeviceModeDefaultSource(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource r)
 735 {
 736         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 737         return NDR_ERR_SUCCESS;
 738 }
 739
 740 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDefaultSource(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource *r)
 741 {
 742         uint16_t v;
 743         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 744         *r = v;
 745         return NDR_ERR_SUCCESS;
 746 }
 747
 748 _PUBLIC_ void ndr_print_spoolss_DeviceModeDefaultSource(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDefaultSource r)
 749 {
 750         const char *val = NULL;
 751
 752         switch (r) {
 753                 case DMBIN_UPPER: val = "DMBIN_UPPER"; break;
 754                 case DMBIN_LOWER: val = "DMBIN_LOWER"; break;
 755                 case DMBIN_MIDDLE: val = "DMBIN_MIDDLE"; break;
 756                 case DMBIN_MANUAL: val = "DMBIN_MANUAL"; break;
 757                 case DMBIN_ENVELOPE: val = "DMBIN_ENVELOPE"; break;
 758                 case DMBIN_ENVMANUAL: val = "DMBIN_ENVMANUAL"; break;
 759                 case DMBIN_AUTO: val = "DMBIN_AUTO"; break;
 760                 case DMBIN_TRACTOR: val = "DMBIN_TRACTOR"; break;
 761                 case DMBIN_SMALLFMT: val = "DMBIN_SMALLFMT"; break;
 762                 case DMBIN_LARGEFMT: val = "DMBIN_LARGEFMT"; break;
 763                 case DMBIN_LARGECAPACITY: val = "DMBIN_LARGECAPACITY"; break;
 764                 case DMBIN_CASSETTE: val = "DMBIN_CASSETTE"; break;
 765                 case DMBIN_FORMSOURCE: val = "DMBIN_FORMSOURCE"; break;
 766         }
 767         ndr_print_enum(ndr, name, "ENUM", val, r);
 768 }
 769
 770 static enum ndr_err_code ndr_push_spoolss_DeviceModePrintQuality(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality r)
 771 {
 772         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 773         return NDR_ERR_SUCCESS;
 774 }
 775
 776 static enum ndr_err_code ndr_pull_spoolss_DeviceModePrintQuality(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality *r)
 777 {
 778         uint16_t v;
 779         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 780         *r = v;
 781         return NDR_ERR_SUCCESS;
 782 }
 783
 784 _PUBLIC_ void ndr_print_spoolss_DeviceModePrintQuality(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePrintQuality r)
 785 {
 786         const char *val = NULL;
 787
 788         switch (r) {
 789                 case DMRES_HIGH: val = "DMRES_HIGH"; break;
 790                 case DMRES_MEDIUM: val = "DMRES_MEDIUM"; break;
 791                 case DMRES_LOW: val = "DMRES_LOW"; break;
 792                 case DMRES_DRAFT: val = "DMRES_DRAFT"; break;
 793         }
 794         ndr_print_enum(ndr, name, "ENUM", val, r);
 795 }
 796
 797 static enum ndr_err_code ndr_push_spoolss_DeviceModeColor(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeColor r)
 798 {
 799         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 800         return NDR_ERR_SUCCESS;
 801 }
 802
 803 static enum ndr_err_code ndr_pull_spoolss_DeviceModeColor(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeColor *r)
 804 {
 805         uint16_t v;
 806         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 807         *r = v;
 808         return NDR_ERR_SUCCESS;
 809 }
 810
 811 _PUBLIC_ void ndr_print_spoolss_DeviceModeColor(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeColor r)
 812 {
 813         const char *val = NULL;
 814
 815         switch (r) {
 816                 case DMRES_MONOCHROME: val = "DMRES_MONOCHROME"; break;
 817                 case DMRES_COLOR: val = "DMRES_COLOR"; break;
 818         }
 819         ndr_print_enum(ndr, name, "ENUM", val, r);
 820 }
 821
 822 static enum ndr_err_code ndr_push_spoolss_DeviceModeDuplex(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex r)
 823 {
 824         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 825         return NDR_ERR_SUCCESS;
 826 }
 827
 828 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDuplex(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex *r)
 829 {
 830         uint16_t v;
 831         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 832         *r = v;
 833         return NDR_ERR_SUCCESS;
 834 }
 835
 836 _PUBLIC_ void ndr_print_spoolss_DeviceModeDuplex(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDuplex r)
 837 {
 838         const char *val = NULL;
 839
 840         switch (r) {
 841                 case DMDUP_SIMPLEX: val = "DMDUP_SIMPLEX"; break;
 842                 case DMDUP_VERTICAL: val = "DMDUP_VERTICAL"; break;
 843                 case DMDUP_HORIZONTAL: val = "DMDUP_HORIZONTAL"; break;
 844         }
 845         ndr_print_enum(ndr, name, "ENUM", val, r);
 846 }
 847
 848 static enum ndr_err_code ndr_push_spoolss_DeviceModeTTOption(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption r)
 849 {
 850         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 851         return NDR_ERR_SUCCESS;
 852 }
 853
 854 static enum ndr_err_code ndr_pull_spoolss_DeviceModeTTOption(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption *r)
 855 {
 856         uint16_t v;
 857         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 858         *r = v;
 859         return NDR_ERR_SUCCESS;
 860 }
 861
 862 _PUBLIC_ void ndr_print_spoolss_DeviceModeTTOption(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeTTOption r)
 863 {
 864         const char *val = NULL;
 865
 866         switch (r) {
 867                 case DMTT_BITMAP: val = "DMTT_BITMAP"; break;
 868                 case DMTT_DOWNLOAD: val = "DMTT_DOWNLOAD"; break;
 869                 case DMTT_SUBDEV: val = "DMTT_SUBDEV"; break;
 870                 case DMTT_DOWNLOAD_OUTLINE: val = "DMTT_DOWNLOAD_OUTLINE"; break;
 871         }
 872         ndr_print_enum(ndr, name, "ENUM", val, r);
 873 }
 874
 875 static enum ndr_err_code ndr_push_spoolss_DeviceModeCollate(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeCollate r)
 876 {
 877         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 878         return NDR_ERR_SUCCESS;
 879 }
 880
 881 static enum ndr_err_code ndr_pull_spoolss_DeviceModeCollate(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeCollate *r)
 882 {
 883         uint16_t v;
 884         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 885         *r = v;
 886         return NDR_ERR_SUCCESS;
 887 }
 888
 889 _PUBLIC_ void ndr_print_spoolss_DeviceModeCollate(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeCollate r)
 890 {
 891         const char *val = NULL;
 892
 893         switch (r) {
 894                 case DMCOLLATE_FALSE: val = "DMCOLLATE_FALSE"; break;
 895                 case DMCOLLATE_TRUE: val = "DMCOLLATE_TRUE"; break;
 896         }
 897         ndr_print_enum(ndr, name, "ENUM", val, r);
 898 }
 899
 900 static enum ndr_err_code ndr_push_spoolss_DeviceModeNUp(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeNUp r)
 901 {
 902         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 903         return NDR_ERR_SUCCESS;
 904 }
 905
 906 static enum ndr_err_code ndr_pull_spoolss_DeviceModeNUp(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeNUp *r)
 907 {
 908         uint32_t v;
 909         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 910         *r = v;
 911         return NDR_ERR_SUCCESS;
 912 }
 913
 914 _PUBLIC_ void ndr_print_spoolss_DeviceModeNUp(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeNUp r)
 915 {
 916         const char *val = NULL;
 917
 918         switch (r) {
 919                 case DMNUP_SYSTEM: val = "DMNUP_SYSTEM"; break;
 920                 case DMNUP_ONEUP: val = "DMNUP_ONEUP"; break;
 921         }
 922         ndr_print_enum(ndr, name, "ENUM", val, r);
 923 }
 924
 925 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMMethod(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod r)
 926 {
 927         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 928         return NDR_ERR_SUCCESS;
 929 }
 930
 931 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMMethod(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod *r)
 932 {
 933         uint32_t v;
 934         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 935         *r = v;
 936         return NDR_ERR_SUCCESS;
 937 }
 938
 939 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMMethod(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMMethod r)
 940 {
 941         const char *val = NULL;
 942
 943         switch (r) {
 944                 case DMICMMETHOD_NONE: val = "DMICMMETHOD_NONE"; break;
 945                 case DMICMMETHOD_SYSTEM: val = "DMICMMETHOD_SYSTEM"; break;
 946                 case DMICMMETHOD_DRIVER: val = "DMICMMETHOD_DRIVER"; break;
 947                 case DMICMMETHOD_DEVICE: val = "DMICMMETHOD_DEVICE"; break;
 948         }
 949         ndr_print_enum(ndr, name, "ENUM", val, r);
 950 }
 951
 952 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMIntent(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent r)
 953 {
 954         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 955         return NDR_ERR_SUCCESS;
 956 }
 957
 958 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMIntent(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent *r)
 959 {
 960         uint32_t v;
 961         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 962         *r = v;
 963         return NDR_ERR_SUCCESS;
 964 }
 965
 966 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMIntent(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMIntent r)
 967 {
 968         const char *val = NULL;
 969
 970         switch (r) {
 971                 case DMICM_SATURATE: val = "DMICM_SATURATE"; break;
 972                 case DMICM_CONTRAST: val = "DMICM_CONTRAST"; break;
 973                 case DMICM_COLORIMETRIC: val = "DMICM_COLORIMETRIC"; break;
 974                 case DMICM_ABS_COLORIMETRIC: val = "DMICM_ABS_COLORIMETRIC"; break;
 975         }
 976         ndr_print_enum(ndr, name, "ENUM", val, r);
 977 }
 978
 979 static enum ndr_err_code ndr_push_spoolss_DeviceModeMediaType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType r)
 980 {
 981         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 982         return NDR_ERR_SUCCESS;
 983 }
 984
 985 static enum ndr_err_code ndr_pull_spoolss_DeviceModeMediaType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType *r)
 986 {
 987         uint32_t v;
 988         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 989         *r = v;
 990         return NDR_ERR_SUCCESS;
 991 }
 992
 993 _PUBLIC_ void ndr_print_spoolss_DeviceModeMediaType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeMediaType r)
 994 {
 995         const char *val = NULL;
 996
 997         switch (r) {
 998                 case DMMEDIA_STANDARD: val = "DMMEDIA_STANDARD"; break;
 999                 case DMMEDIA_TRANSPARENCY: val = "DMMEDIA_TRANSPARENCY"; break;
1000                 case DMMEDIA_GLOSSY: val = "DMMEDIA_GLOSSY"; break;
1001         }
1002         ndr_print_enum(ndr, name, "ENUM", val, r);
1003 }
1004
1005 static enum ndr_err_code ndr_push_spoolss_DeviceModeDitherType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType r)
1006 {
1007         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1008         return NDR_ERR_SUCCESS;
1009 }
1010
1011 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDitherType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType *r)
1012 {
1013         uint32_t v;
1014         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1015         *r = v;
1016         return NDR_ERR_SUCCESS;
1017 }
1018
1019 _PUBLIC_ void ndr_print_spoolss_DeviceModeDitherType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDitherType r)
1020 {
1021         const char *val = NULL;
1022
1023         switch (r) {
1024                 case DMDITHER_NONE: val = "DMDITHER_NONE"; break;
1025                 case DMDITHER_COARSE: val = "DMDITHER_COARSE"; break;
1026                 case DMDITHER_FINE: val = "DMDITHER_FINE"; break;
1027                 case DMDITHER_LINEART: val = "DMDITHER_LINEART"; break;
1028                 case DMDITHER_ERRORDIFFUSION: val = "DMDITHER_ERRORDIFFUSION"; break;
1029                 case DMDITHER_RESERVED6: val = "DMDITHER_RESERVED6"; break;
1030                 case DMDITHER_RESERVED7: val = "DMDITHER_RESERVED7"; break;
1031                 case DMDITHER_RESERVED8: val = "DMDITHER_RESERVED8"; break;
1032                 case DMDITHER_RESERVED9: val = "DMDITHER_RESERVED9"; break;
1033                 case DMDITHER_GRAYSCALE: val = "DMDITHER_GRAYSCALE"; break;
1034         }
1035         ndr_print_enum(ndr, name, "ENUM", val, r);
1036 }
1037
1038 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
1039 {
1040         if (ndr_flags & NDR_SCALARS) {
1041                 NDR_CHECK(ndr_push_align(ndr, 4));
1042                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, 32, sizeof(uint16_t), CH_UTF16));
1043                 NDR_CHECK(ndr_push_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, r->specversion));
1044                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
1045                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
1046                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
1047                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
1048                 NDR_CHECK(ndr_push_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, r->orientation));
1049                 NDR_CHECK(ndr_push_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, r->papersize));
1050                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
1051                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
1052                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
1053                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
1054                 NDR_CHECK(ndr_push_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, r->defaultsource));
1055                 NDR_CHECK(ndr_push_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, r->printquality));
1056                 NDR_CHECK(ndr_push_spoolss_DeviceModeColor(ndr, NDR_SCALARS, r->color));
1057                 NDR_CHECK(ndr_push_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, r->duplex));
1058                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
1059                 NDR_CHECK(ndr_push_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, r->ttoption));
1060                 NDR_CHECK(ndr_push_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, r->collate));
1061                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 32, sizeof(uint16_t), CH_UTF16));
1062                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
1063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
1064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
1065                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
1066                 NDR_CHECK(ndr_push_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, r->displayflags));
1067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
1068                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, r->icmmethod));
1069                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, r->icmintent));
1070                 NDR_CHECK(ndr_push_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, r->mediatype));
1071                 NDR_CHECK(ndr_push_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, r->dithertype));
1072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
1073                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
1074                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
1075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
1076                 {
1077                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1078                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1079                         {
1080                                 struct ndr_push *_ndr_driverextra_data;
1081                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
1082                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
1083                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
1084                         }
1085                         ndr->flags = _flags_save_DATA_BLOB;
1086                 }
1087         }
1088         if (ndr_flags & NDR_BUFFERS) {
1089         }
1090         return NDR_ERR_SUCCESS;
1091 }
1092
1093 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
1094 {
1095         if (ndr_flags & NDR_SCALARS) {
1096                 NDR_CHECK(ndr_pull_align(ndr, 4));
1097                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, 32, sizeof(uint16_t), CH_UTF16));
1098                 NDR_CHECK(ndr_pull_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, &r->specversion));
1099                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
1100                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
1101                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
1102                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
1103                 NDR_CHECK(ndr_pull_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, &r->orientation));
1104                 NDR_CHECK(ndr_pull_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, &r->papersize));
1105                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
1106                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
1107                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
1108                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
1109                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, &r->defaultsource));
1110                 NDR_CHECK(ndr_pull_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, &r->printquality));
1111                 NDR_CHECK(ndr_pull_spoolss_DeviceModeColor(ndr, NDR_SCALARS, &r->color));
1112                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, &r->duplex));
1113                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
1114                 NDR_CHECK(ndr_pull_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, &r->ttoption));
1115                 NDR_CHECK(ndr_pull_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, &r->collate));
1116                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 32, sizeof(uint16_t), CH_UTF16));
1117                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
1118                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
1119                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
1120                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
1121                 NDR_CHECK(ndr_pull_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, &r->displayflags));
1122                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
1123                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, &r->icmmethod));
1124                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, &r->icmintent));
1125                 NDR_CHECK(ndr_pull_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, &r->mediatype));
1126                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, &r->dithertype));
1127                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1128                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1129                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
1130                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
1131                 {
1132                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1133                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1134                         {
1135                                 struct ndr_pull *_ndr_driverextra_data;
1136                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
1137                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
1138                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
1139                         }
1140                         ndr->flags = _flags_save_DATA_BLOB;
1141                 }
1142         }
1143         if (ndr_flags & NDR_BUFFERS) {
1144         }
1145         return NDR_ERR_SUCCESS;
1146 }
1147
1148 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
1149 {
1150         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
1151         ndr->depth++;
1152         ndr_print_string(ndr, "devicename", r->devicename);
1153         ndr_print_spoolss_DeviceModeSpecVersion(ndr, "specversion", r->specversion);
1154         ndr_print_uint16(ndr, "driverversion", r->driverversion);
1155         ndr_print_uint16(ndr, "size", r->size);
1156         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
1157         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
1158         ndr_print_spoolss_DeviceModeOrientation(ndr, "orientation", r->orientation);
1159         ndr_print_spoolss_DeviceModePaperSize(ndr, "papersize", r->papersize);
1160         ndr_print_uint16(ndr, "paperlength", r->paperlength);
1161         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
1162         ndr_print_uint16(ndr, "scale", r->scale);
1163         ndr_print_uint16(ndr, "copies", r->copies);
1164         ndr_print_spoolss_DeviceModeDefaultSource(ndr, "defaultsource", r->defaultsource);
1165         ndr_print_spoolss_DeviceModePrintQuality(ndr, "printquality", r->printquality);
1166         ndr_print_spoolss_DeviceModeColor(ndr, "color", r->color);
1167         ndr_print_spoolss_DeviceModeDuplex(ndr, "duplex", r->duplex);
1168         ndr_print_uint16(ndr, "yresolution", r->yresolution);
1169         ndr_print_spoolss_DeviceModeTTOption(ndr, "ttoption", r->ttoption);
1170         ndr_print_spoolss_DeviceModeCollate(ndr, "collate", r->collate);
1171         ndr_print_string(ndr, "formname", r->formname);
1172         ndr_print_uint16(ndr, "logpixels", r->logpixels);
1173         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
1174         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
1175         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
1176         ndr_print_spoolss_DeviceModeNUp(ndr, "displayflags", r->displayflags);
1177         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
1178         ndr_print_spoolss_DeviceModeICMMethod(ndr, "icmmethod", r->icmmethod);
1179         ndr_print_spoolss_DeviceModeICMIntent(ndr, "icmintent", r->icmintent);
1180         ndr_print_spoolss_DeviceModeMediaType(ndr, "mediatype", r->mediatype);
1181         ndr_print_spoolss_DeviceModeDitherType(ndr, "dithertype", r->dithertype);
1182         ndr_print_uint32(ndr, "reserved1", r->reserved1);
1183         ndr_print_uint32(ndr, "reserved2", r->reserved2);
1184         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
1185         ndr_print_uint32(ndr, "panningheight", r->panningheight);
1186         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
1187         ndr->depth--;
1188 }
1189
1190 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
1191 {
1192         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
1193 }
1194
1195 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1196 {
1197         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1198         return NDR_ERR_SUCCESS;
1199 }
1200
1201 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1202 {
1203         uint32_t v;
1204         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1205         *r = v;
1206         return NDR_ERR_SUCCESS;
1207 }
1208
1209 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
1210 {
1211         ndr_print_uint32(ndr, name, r);
1212         ndr->depth++;
1213         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
1214         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
1215         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
1216         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
1217         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
1218         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
1219         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
1220         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
1221         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
1222         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
1223         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
1224         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
1225         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
1226         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
1227         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
1228         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
1229         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
1230         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
1231         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
1232         ndr->depth--;
1233 }
1234
1235 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1236 {
1237         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1238         return NDR_ERR_SUCCESS;
1239 }
1240
1241 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1242 {
1243         uint32_t v;
1244         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1245         *r = v;
1246         return NDR_ERR_SUCCESS;
1247 }
1248
1249 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
1250 {
1251         ndr_print_uint32(ndr, name, r);
1252         ndr->depth++;
1253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
1254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
1255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
1256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
1257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
1258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
1259         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
1260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
1261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
1262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
1263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
1264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
1265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
1266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
1267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
1268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
1269         ndr->depth--;
1270 }
1271
1272 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
1273 {
1274         if (ndr_flags & NDR_SCALARS) {
1275                 NDR_CHECK(ndr_push_align(ndr, 4));
1276                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
1277                 {
1278                         uint32_t _flags_save_string = ndr->flags;
1279                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1280                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
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_push_relative_ptr1(ndr, r->name));
1287                         ndr->flags = _flags_save_string;
1288                 }
1289                 {
1290                         uint32_t _flags_save_string = ndr->flags;
1291                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1292                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1293                         ndr->flags = _flags_save_string;
1294                 }
1295         }
1296         if (ndr_flags & NDR_BUFFERS) {
1297                 {
1298                         uint32_t _flags_save_string = ndr->flags;
1299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1300                         if (r->description) {
1301                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
1302                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
1303                         }
1304                         ndr->flags = _flags_save_string;
1305                 }
1306                 {
1307                         uint32_t _flags_save_string = ndr->flags;
1308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1309                         if (r->name) {
1310                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
1311                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
1312                         }
1313                         ndr->flags = _flags_save_string;
1314                 }
1315                 {
1316                         uint32_t _flags_save_string = ndr->flags;
1317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1318                         if (r->comment) {
1319                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1320                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1321                         }
1322                         ndr->flags = _flags_save_string;
1323                 }
1324         }
1325         return NDR_ERR_SUCCESS;
1326 }
1327
1328 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
1329 {
1330         uint32_t _ptr_description;
1331         TALLOC_CTX *_mem_save_description_0;
1332         uint32_t _ptr_name;
1333         TALLOC_CTX *_mem_save_name_0;
1334         uint32_t _ptr_comment;
1335         TALLOC_CTX *_mem_save_comment_0;
1336         if (ndr_flags & NDR_SCALARS) {
1337                 NDR_CHECK(ndr_pull_align(ndr, 4));
1338                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
1339                 {
1340                         uint32_t _flags_save_string = ndr->flags;
1341                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1342                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
1343                         if (_ptr_description) {
1344                                 NDR_PULL_ALLOC(ndr, r->description);
1345                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
1346                         } else {
1347                                 r->description = NULL;
1348                         }
1349                         ndr->flags = _flags_save_string;
1350                 }
1351                 {
1352                         uint32_t _flags_save_string = ndr->flags;
1353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1354                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
1355                         if (_ptr_name) {
1356                                 NDR_PULL_ALLOC(ndr, r->name);
1357                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
1358                         } else {
1359                                 r->name = NULL;
1360                         }
1361                         ndr->flags = _flags_save_string;
1362                 }
1363                 {
1364                         uint32_t _flags_save_string = ndr->flags;
1365                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1366                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1367                         if (_ptr_comment) {
1368                                 NDR_PULL_ALLOC(ndr, r->comment);
1369                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1370                         } else {
1371                                 r->comment = NULL;
1372                         }
1373                         ndr->flags = _flags_save_string;
1374                 }
1375         }
1376         if (ndr_flags & NDR_BUFFERS) {
1377                 {
1378                         uint32_t _flags_save_string = ndr->flags;
1379                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1380                         if (r->description) {
1381                                 uint32_t _relative_save_offset;
1382                                 _relative_save_offset = ndr->offset;
1383                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
1384                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
1385                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
1386                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
1387                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
1388                                 ndr->offset = _relative_save_offset;
1389                         }
1390                         ndr->flags = _flags_save_string;
1391                 }
1392                 {
1393                         uint32_t _flags_save_string = ndr->flags;
1394                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1395                         if (r->name) {
1396                                 uint32_t _relative_save_offset;
1397                                 _relative_save_offset = ndr->offset;
1398                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
1399                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1400                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
1401                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
1402                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
1403                                 ndr->offset = _relative_save_offset;
1404                         }
1405                         ndr->flags = _flags_save_string;
1406                 }
1407                 {
1408                         uint32_t _flags_save_string = ndr->flags;
1409                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1410                         if (r->comment) {
1411                                 uint32_t _relative_save_offset;
1412                                 _relative_save_offset = ndr->offset;
1413                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1414                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1415                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1416                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1417                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1418                                 ndr->offset = _relative_save_offset;
1419                         }
1420                         ndr->flags = _flags_save_string;
1421                 }
1422         }
1423         return NDR_ERR_SUCCESS;
1424 }
1425
1426 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
1427 {
1428         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
1429         ndr->depth++;
1430         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
1431         ndr_print_ptr(ndr, "description", r->description);
1432         ndr->depth++;
1433         if (r->description) {
1434                 ndr_print_string(ndr, "description", r->description);
1435         }
1436         ndr->depth--;
1437         ndr_print_ptr(ndr, "name", r->name);
1438         ndr->depth++;
1439         if (r->name) {
1440                 ndr_print_string(ndr, "name", r->name);
1441         }
1442         ndr->depth--;
1443         ndr_print_ptr(ndr, "comment", r->comment);
1444         ndr->depth++;
1445         if (r->comment) {
1446                 ndr_print_string(ndr, "comment", r->comment);
1447         }
1448         ndr->depth--;
1449         ndr->depth--;
1450 }
1451
1452 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo1(const struct spoolss_PrinterInfo1 *r, struct smb_iconv_convenience *ic, int flags)
1453 {
1454         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1, ic);
1455 }
1456
1457 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
1458 {
1459         if (ndr_flags & NDR_SCALARS) {
1460                 NDR_CHECK(ndr_push_align(ndr, 4));
1461                 {
1462                         uint32_t _flags_save_string = ndr->flags;
1463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1464                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1465                         ndr->flags = _flags_save_string;
1466                 }
1467                 {
1468                         uint32_t _flags_save_string = ndr->flags;
1469                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1470                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
1477                         ndr->flags = _flags_save_string;
1478                 }
1479                 {
1480                         uint32_t _flags_save_string = ndr->flags;
1481                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1482                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1483                         ndr->flags = _flags_save_string;
1484                 }
1485                 {
1486                         uint32_t _flags_save_string = ndr->flags;
1487                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1488                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1489                         ndr->flags = _flags_save_string;
1490                 }
1491                 {
1492                         uint32_t _flags_save_string = ndr->flags;
1493                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1494                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1495                         ndr->flags = _flags_save_string;
1496                 }
1497                 {
1498                         uint32_t _flags_save_string = ndr->flags;
1499                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1500                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1501                         ndr->flags = _flags_save_string;
1502                 }
1503                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1504                 {
1505                         uint32_t _flags_save_string = ndr->flags;
1506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1507                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1508                         ndr->flags = _flags_save_string;
1509                 }
1510                 {
1511                         uint32_t _flags_save_string = ndr->flags;
1512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1513                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1514                         ndr->flags = _flags_save_string;
1515                 }
1516                 {
1517                         uint32_t _flags_save_string = ndr->flags;
1518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1519                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1520                         ndr->flags = _flags_save_string;
1521                 }
1522                 {
1523                         uint32_t _flags_save_string = ndr->flags;
1524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1525                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1526                         ndr->flags = _flags_save_string;
1527                 }
1528                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1529                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1534                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1537         }
1538         if (ndr_flags & NDR_BUFFERS) {
1539                 {
1540                         uint32_t _flags_save_string = ndr->flags;
1541                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1542                         if (r->servername) {
1543                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1544                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1545                         }
1546                         ndr->flags = _flags_save_string;
1547                 }
1548                 {
1549                         uint32_t _flags_save_string = ndr->flags;
1550                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1551                         if (r->printername) {
1552                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1553                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1554                         }
1555                         ndr->flags = _flags_save_string;
1556                 }
1557                 {
1558                         uint32_t _flags_save_string = ndr->flags;
1559                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1560                         if (r->sharename) {
1561                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1562                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1563                         }
1564                         ndr->flags = _flags_save_string;
1565                 }
1566                 {
1567                         uint32_t _flags_save_string = ndr->flags;
1568                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1569                         if (r->portname) {
1570                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1571                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1572                         }
1573                         ndr->flags = _flags_save_string;
1574                 }
1575                 {
1576                         uint32_t _flags_save_string = ndr->flags;
1577                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1578                         if (r->drivername) {
1579                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1580                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1581                         }
1582                         ndr->flags = _flags_save_string;
1583                 }
1584                 {
1585                         uint32_t _flags_save_string = ndr->flags;
1586                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1587                         if (r->comment) {
1588                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1589                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1590                         }
1591                         ndr->flags = _flags_save_string;
1592                 }
1593                 {
1594                         uint32_t _flags_save_string = ndr->flags;
1595                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1596                         if (r->location) {
1597                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1598                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1599                         }
1600                         ndr->flags = _flags_save_string;
1601                 }
1602                 if (r->devmode) {
1603                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1604                         {
1605                                 struct ndr_push *_ndr_devmode;
1606                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1607                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1608                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1609                         }
1610                 }
1611                 {
1612                         uint32_t _flags_save_string = ndr->flags;
1613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1614                         if (r->sepfile) {
1615                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1616                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1617                         }
1618                         ndr->flags = _flags_save_string;
1619                 }
1620                 {
1621                         uint32_t _flags_save_string = ndr->flags;
1622                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1623                         if (r->printprocessor) {
1624                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1625                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1626                         }
1627                         ndr->flags = _flags_save_string;
1628                 }
1629                 {
1630                         uint32_t _flags_save_string = ndr->flags;
1631                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1632                         if (r->datatype) {
1633                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1634                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1635                         }
1636                         ndr->flags = _flags_save_string;
1637                 }
1638                 {
1639                         uint32_t _flags_save_string = ndr->flags;
1640                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1641                         if (r->parameters) {
1642                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1643                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1644                         }
1645                         ndr->flags = _flags_save_string;
1646                 }
1647                 if (r->secdesc) {
1648                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1649                         {
1650                                 struct ndr_push *_ndr_secdesc;
1651                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1652                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1653                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1654                         }
1655                 }
1656         }
1657         return NDR_ERR_SUCCESS;
1658 }
1659
1660 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1661 {
1662         uint32_t _ptr_servername;
1663         TALLOC_CTX *_mem_save_servername_0;
1664         uint32_t _ptr_printername;
1665         TALLOC_CTX *_mem_save_printername_0;
1666         uint32_t _ptr_sharename;
1667         TALLOC_CTX *_mem_save_sharename_0;
1668         uint32_t _ptr_portname;
1669         TALLOC_CTX *_mem_save_portname_0;
1670         uint32_t _ptr_drivername;
1671         TALLOC_CTX *_mem_save_drivername_0;
1672         uint32_t _ptr_comment;
1673         TALLOC_CTX *_mem_save_comment_0;
1674         uint32_t _ptr_location;
1675         TALLOC_CTX *_mem_save_location_0;
1676         uint32_t _ptr_devmode;
1677         TALLOC_CTX *_mem_save_devmode_0;
1678         uint32_t _ptr_sepfile;
1679         TALLOC_CTX *_mem_save_sepfile_0;
1680         uint32_t _ptr_printprocessor;
1681         TALLOC_CTX *_mem_save_printprocessor_0;
1682         uint32_t _ptr_datatype;
1683         TALLOC_CTX *_mem_save_datatype_0;
1684         uint32_t _ptr_parameters;
1685         TALLOC_CTX *_mem_save_parameters_0;
1686         uint32_t _ptr_secdesc;
1687         TALLOC_CTX *_mem_save_secdesc_0;
1688         if (ndr_flags & NDR_SCALARS) {
1689                 NDR_CHECK(ndr_pull_align(ndr, 4));
1690                 {
1691                         uint32_t _flags_save_string = ndr->flags;
1692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1693                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1694                         if (_ptr_servername) {
1695                                 NDR_PULL_ALLOC(ndr, r->servername);
1696                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1697                         } else {
1698                                 r->servername = NULL;
1699                         }
1700                         ndr->flags = _flags_save_string;
1701                 }
1702                 {
1703                         uint32_t _flags_save_string = ndr->flags;
1704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1705                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1706                         if (_ptr_printername) {
1707                                 NDR_PULL_ALLOC(ndr, r->printername);
1708                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1709                         } else {
1710                                 r->printername = NULL;
1711                         }
1712                         ndr->flags = _flags_save_string;
1713                 }
1714                 {
1715                         uint32_t _flags_save_string = ndr->flags;
1716                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1717                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1718                         if (_ptr_sharename) {
1719                                 NDR_PULL_ALLOC(ndr, r->sharename);
1720                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1721                         } else {
1722                                 r->sharename = NULL;
1723                         }
1724                         ndr->flags = _flags_save_string;
1725                 }
1726                 {
1727                         uint32_t _flags_save_string = ndr->flags;
1728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1729                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1730                         if (_ptr_portname) {
1731                                 NDR_PULL_ALLOC(ndr, r->portname);
1732                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1733                         } else {
1734                                 r->portname = NULL;
1735                         }
1736                         ndr->flags = _flags_save_string;
1737                 }
1738                 {
1739                         uint32_t _flags_save_string = ndr->flags;
1740                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1741                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1742                         if (_ptr_drivername) {
1743                                 NDR_PULL_ALLOC(ndr, r->drivername);
1744                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1745                         } else {
1746                                 r->drivername = NULL;
1747                         }
1748                         ndr->flags = _flags_save_string;
1749                 }
1750                 {
1751                         uint32_t _flags_save_string = ndr->flags;
1752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1753                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1754                         if (_ptr_comment) {
1755                                 NDR_PULL_ALLOC(ndr, r->comment);
1756                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1757                         } else {
1758                                 r->comment = NULL;
1759                         }
1760                         ndr->flags = _flags_save_string;
1761                 }
1762                 {
1763                         uint32_t _flags_save_string = ndr->flags;
1764                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1765                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1766                         if (_ptr_location) {
1767                                 NDR_PULL_ALLOC(ndr, r->location);
1768                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1769                         } else {
1770                                 r->location = NULL;
1771                         }
1772                         ndr->flags = _flags_save_string;
1773                 }
1774                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1775                 if (_ptr_devmode) {
1776                         NDR_PULL_ALLOC(ndr, r->devmode);
1777                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1778                 } else {
1779                         r->devmode = NULL;
1780                 }
1781                 {
1782                         uint32_t _flags_save_string = ndr->flags;
1783                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1784                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1785                         if (_ptr_sepfile) {
1786                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1787                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1788                         } else {
1789                                 r->sepfile = NULL;
1790                         }
1791                         ndr->flags = _flags_save_string;
1792                 }
1793                 {
1794                         uint32_t _flags_save_string = ndr->flags;
1795                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1796                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1797                         if (_ptr_printprocessor) {
1798                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1799                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1800                         } else {
1801                                 r->printprocessor = NULL;
1802                         }
1803                         ndr->flags = _flags_save_string;
1804                 }
1805                 {
1806                         uint32_t _flags_save_string = ndr->flags;
1807                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1808                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1809                         if (_ptr_datatype) {
1810                                 NDR_PULL_ALLOC(ndr, r->datatype);
1811                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1812                         } else {
1813                                 r->datatype = NULL;
1814                         }
1815                         ndr->flags = _flags_save_string;
1816                 }
1817                 {
1818                         uint32_t _flags_save_string = ndr->flags;
1819                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1820                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1821                         if (_ptr_parameters) {
1822                                 NDR_PULL_ALLOC(ndr, r->parameters);
1823                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1824                         } else {
1825                                 r->parameters = NULL;
1826                         }
1827                         ndr->flags = _flags_save_string;
1828                 }
1829                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1830                 if (_ptr_secdesc) {
1831                         NDR_PULL_ALLOC(ndr, r->secdesc);
1832                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1833                 } else {
1834                         r->secdesc = NULL;
1835                 }
1836                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1837                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1838                 if (r->priority > 99) {
1839                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1840                 }
1841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1843                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1844                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1847         }
1848         if (ndr_flags & NDR_BUFFERS) {
1849                 {
1850                         uint32_t _flags_save_string = ndr->flags;
1851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1852                         if (r->servername) {
1853                                 uint32_t _relative_save_offset;
1854                                 _relative_save_offset = ndr->offset;
1855                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1856                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1857                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1858                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1859                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1860                                 ndr->offset = _relative_save_offset;
1861                         }
1862                         ndr->flags = _flags_save_string;
1863                 }
1864                 {
1865                         uint32_t _flags_save_string = ndr->flags;
1866                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1867                         if (r->printername) {
1868                                 uint32_t _relative_save_offset;
1869                                 _relative_save_offset = ndr->offset;
1870                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1871                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1872                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1873                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1874                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1875                                 ndr->offset = _relative_save_offset;
1876                         }
1877                         ndr->flags = _flags_save_string;
1878                 }
1879                 {
1880                         uint32_t _flags_save_string = ndr->flags;
1881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1882                         if (r->sharename) {
1883                                 uint32_t _relative_save_offset;
1884                                 _relative_save_offset = ndr->offset;
1885                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1886                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1887                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1888                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1889                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1890                                 ndr->offset = _relative_save_offset;
1891                         }
1892                         ndr->flags = _flags_save_string;
1893                 }
1894                 {
1895                         uint32_t _flags_save_string = ndr->flags;
1896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1897                         if (r->portname) {
1898                                 uint32_t _relative_save_offset;
1899                                 _relative_save_offset = ndr->offset;
1900                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1901                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1902                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1903                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1904                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1905                                 ndr->offset = _relative_save_offset;
1906                         }
1907                         ndr->flags = _flags_save_string;
1908                 }
1909                 {
1910                         uint32_t _flags_save_string = ndr->flags;
1911                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1912                         if (r->drivername) {
1913                                 uint32_t _relative_save_offset;
1914                                 _relative_save_offset = ndr->offset;
1915                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1916                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1917                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1918                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1919                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1920                                 ndr->offset = _relative_save_offset;
1921                         }
1922                         ndr->flags = _flags_save_string;
1923                 }
1924                 {
1925                         uint32_t _flags_save_string = ndr->flags;
1926                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1927                         if (r->comment) {
1928                                 uint32_t _relative_save_offset;
1929                                 _relative_save_offset = ndr->offset;
1930                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1931                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1932                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1933                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1934                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1935                                 ndr->offset = _relative_save_offset;
1936                         }
1937                         ndr->flags = _flags_save_string;
1938                 }
1939                 {
1940                         uint32_t _flags_save_string = ndr->flags;
1941                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1942                         if (r->location) {
1943                                 uint32_t _relative_save_offset;
1944                                 _relative_save_offset = ndr->offset;
1945                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1946                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1947                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1948                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1949                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1950                                 ndr->offset = _relative_save_offset;
1951                         }
1952                         ndr->flags = _flags_save_string;
1953                 }
1954                 if (r->devmode) {
1955                         uint32_t _relative_save_offset;
1956                         _relative_save_offset = ndr->offset;
1957                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1958                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1959                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1960                         {
1961                                 struct ndr_pull *_ndr_devmode;
1962                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1963                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1964                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1965                         }
1966                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1967                         ndr->offset = _relative_save_offset;
1968                 }
1969                 {
1970                         uint32_t _flags_save_string = ndr->flags;
1971                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1972                         if (r->sepfile) {
1973                                 uint32_t _relative_save_offset;
1974                                 _relative_save_offset = ndr->offset;
1975                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1976                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1977                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1978                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1979                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1980                                 ndr->offset = _relative_save_offset;
1981                         }
1982                         ndr->flags = _flags_save_string;
1983                 }
1984                 {
1985                         uint32_t _flags_save_string = ndr->flags;
1986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1987                         if (r->printprocessor) {
1988                                 uint32_t _relative_save_offset;
1989                                 _relative_save_offset = ndr->offset;
1990                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1991                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1992                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1993                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1994                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1995                                 ndr->offset = _relative_save_offset;
1996                         }
1997                         ndr->flags = _flags_save_string;
1998                 }
1999                 {
2000                         uint32_t _flags_save_string = ndr->flags;
2001                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2002                         if (r->datatype) {
2003                                 uint32_t _relative_save_offset;
2004                                 _relative_save_offset = ndr->offset;
2005                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
2006                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
2007                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
2008                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
2009                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
2010                                 ndr->offset = _relative_save_offset;
2011                         }
2012                         ndr->flags = _flags_save_string;
2013                 }
2014                 {
2015                         uint32_t _flags_save_string = ndr->flags;
2016                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2017                         if (r->parameters) {
2018                                 uint32_t _relative_save_offset;
2019                                 _relative_save_offset = ndr->offset;
2020                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
2021                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
2022                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
2023                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
2024                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
2025                                 ndr->offset = _relative_save_offset;
2026                         }
2027                         ndr->flags = _flags_save_string;
2028                 }
2029                 if (r->secdesc) {
2030                         uint32_t _relative_save_offset;
2031                         _relative_save_offset = ndr->offset;
2032                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2033                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2034                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2035                         {
2036                                 struct ndr_pull *_ndr_secdesc;
2037                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2038                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2039                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2040                         }
2041                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2042                         ndr->offset = _relative_save_offset;
2043                 }
2044         }
2045         return NDR_ERR_SUCCESS;
2046 }
2047
2048 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
2049 {
2050         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
2051         ndr->depth++;
2052         ndr_print_ptr(ndr, "servername", r->servername);
2053         ndr->depth++;
2054         if (r->servername) {
2055                 ndr_print_string(ndr, "servername", r->servername);
2056         }
2057         ndr->depth--;
2058         ndr_print_ptr(ndr, "printername", r->printername);
2059         ndr->depth++;
2060         if (r->printername) {
2061                 ndr_print_string(ndr, "printername", r->printername);
2062         }
2063         ndr->depth--;
2064         ndr_print_ptr(ndr, "sharename", r->sharename);
2065         ndr->depth++;
2066         if (r->sharename) {
2067                 ndr_print_string(ndr, "sharename", r->sharename);
2068         }
2069         ndr->depth--;
2070         ndr_print_ptr(ndr, "portname", r->portname);
2071         ndr->depth++;
2072         if (r->portname) {
2073                 ndr_print_string(ndr, "portname", r->portname);
2074         }
2075         ndr->depth--;
2076         ndr_print_ptr(ndr, "drivername", r->drivername);
2077         ndr->depth++;
2078         if (r->drivername) {
2079                 ndr_print_string(ndr, "drivername", r->drivername);
2080         }
2081         ndr->depth--;
2082         ndr_print_ptr(ndr, "comment", r->comment);
2083         ndr->depth++;
2084         if (r->comment) {
2085                 ndr_print_string(ndr, "comment", r->comment);
2086         }
2087         ndr->depth--;
2088         ndr_print_ptr(ndr, "location", r->location);
2089         ndr->depth++;
2090         if (r->location) {
2091                 ndr_print_string(ndr, "location", r->location);
2092         }
2093         ndr->depth--;
2094         ndr_print_ptr(ndr, "devmode", r->devmode);
2095         ndr->depth++;
2096         if (r->devmode) {
2097                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2098         }
2099         ndr->depth--;
2100         ndr_print_ptr(ndr, "sepfile", r->sepfile);
2101         ndr->depth++;
2102         if (r->sepfile) {
2103                 ndr_print_string(ndr, "sepfile", r->sepfile);
2104         }
2105         ndr->depth--;
2106         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
2107         ndr->depth++;
2108         if (r->printprocessor) {
2109                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
2110         }
2111         ndr->depth--;
2112         ndr_print_ptr(ndr, "datatype", r->datatype);
2113         ndr->depth++;
2114         if (r->datatype) {
2115                 ndr_print_string(ndr, "datatype", r->datatype);
2116         }
2117         ndr->depth--;
2118         ndr_print_ptr(ndr, "parameters", r->parameters);
2119         ndr->depth++;
2120         if (r->parameters) {
2121                 ndr_print_string(ndr, "parameters", r->parameters);
2122         }
2123         ndr->depth--;
2124         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2125         ndr->depth++;
2126         if (r->secdesc) {
2127                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
2128         }
2129         ndr->depth--;
2130         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2131         ndr_print_uint32(ndr, "priority", r->priority);
2132         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
2133         ndr_print_uint32(ndr, "starttime", r->starttime);
2134         ndr_print_uint32(ndr, "untiltime", r->untiltime);
2135         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2136         ndr_print_uint32(ndr, "cjobs", r->cjobs);
2137         ndr_print_uint32(ndr, "averageppm", r->averageppm);
2138         ndr->depth--;
2139 }
2140
2141 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo2(const struct spoolss_PrinterInfo2 *r, struct smb_iconv_convenience *ic, int flags)
2142 {
2143         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2, ic);
2144 }
2145
2146 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
2147 {
2148         if (ndr_flags & NDR_SCALARS) {
2149                 NDR_CHECK(ndr_push_align(ndr, 4));
2150                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
2151         }
2152         if (ndr_flags & NDR_BUFFERS) {
2153                 if (r->secdesc) {
2154                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
2155                         {
2156                                 struct ndr_push *_ndr_secdesc;
2157                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2158                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2159                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2160                         }
2161                 }
2162         }
2163         return NDR_ERR_SUCCESS;
2164 }
2165
2166 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
2167 {
2168         uint32_t _ptr_secdesc;
2169         TALLOC_CTX *_mem_save_secdesc_0;
2170         if (ndr_flags & NDR_SCALARS) {
2171                 NDR_CHECK(ndr_pull_align(ndr, 4));
2172                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
2173                 if (_ptr_secdesc) {
2174                         NDR_PULL_ALLOC(ndr, r->secdesc);
2175                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
2176                 } else {
2177                         r->secdesc = NULL;
2178                 }
2179         }
2180         if (ndr_flags & NDR_BUFFERS) {
2181                 if (r->secdesc) {
2182                         uint32_t _relative_save_offset;
2183                         _relative_save_offset = ndr->offset;
2184                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2185                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2186                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2187                         {
2188                                 struct ndr_pull *_ndr_secdesc;
2189                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2190                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2191                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2192                         }
2193                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2194                         ndr->offset = _relative_save_offset;
2195                 }
2196         }
2197         return NDR_ERR_SUCCESS;
2198 }
2199
2200 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
2201 {
2202         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
2203         ndr->depth++;
2204         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2205         ndr->depth++;
2206         if (r->secdesc) {
2207                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
2208         }
2209         ndr->depth--;
2210         ndr->depth--;
2211 }
2212
2213 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo3(const struct spoolss_PrinterInfo3 *r, struct smb_iconv_convenience *ic, int flags)
2214 {
2215         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo3, ic);
2216 }
2217
2218 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
2219 {
2220         if (ndr_flags & NDR_SCALARS) {
2221                 NDR_CHECK(ndr_push_align(ndr, 4));
2222                 {
2223                         uint32_t _flags_save_string = ndr->flags;
2224                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2225                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2226                         ndr->flags = _flags_save_string;
2227                 }
2228                 {
2229                         uint32_t _flags_save_string = ndr->flags;
2230                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2231                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
2232                         ndr->flags = _flags_save_string;
2233                 }
2234                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2235         }
2236         if (ndr_flags & NDR_BUFFERS) {
2237                 {
2238                         uint32_t _flags_save_string = ndr->flags;
2239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2240                         if (r->printername) {
2241                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
2242                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2243                         }
2244                         ndr->flags = _flags_save_string;
2245                 }
2246                 {
2247                         uint32_t _flags_save_string = ndr->flags;
2248                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2249                         if (r->servername) {
2250                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
2251                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
2252                         }
2253                         ndr->flags = _flags_save_string;
2254                 }
2255         }
2256         return NDR_ERR_SUCCESS;
2257 }
2258
2259 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
2260 {
2261         uint32_t _ptr_printername;
2262         TALLOC_CTX *_mem_save_printername_0;
2263         uint32_t _ptr_servername;
2264         TALLOC_CTX *_mem_save_servername_0;
2265         if (ndr_flags & NDR_SCALARS) {
2266                 NDR_CHECK(ndr_pull_align(ndr, 4));
2267                 {
2268                         uint32_t _flags_save_string = ndr->flags;
2269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2270                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2271                         if (_ptr_printername) {
2272                                 NDR_PULL_ALLOC(ndr, r->printername);
2273                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2274                         } else {
2275                                 r->printername = NULL;
2276                         }
2277                         ndr->flags = _flags_save_string;
2278                 }
2279                 {
2280                         uint32_t _flags_save_string = ndr->flags;
2281                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2282                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
2283                         if (_ptr_servername) {
2284                                 NDR_PULL_ALLOC(ndr, r->servername);
2285                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
2286                         } else {
2287                                 r->servername = NULL;
2288                         }
2289                         ndr->flags = _flags_save_string;
2290                 }
2291                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2292         }
2293         if (ndr_flags & NDR_BUFFERS) {
2294                 {
2295                         uint32_t _flags_save_string = ndr->flags;
2296                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2297                         if (r->printername) {
2298                                 uint32_t _relative_save_offset;
2299                                 _relative_save_offset = ndr->offset;
2300                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2301                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2302                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2303                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2304                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2305                                 ndr->offset = _relative_save_offset;
2306                         }
2307                         ndr->flags = _flags_save_string;
2308                 }
2309                 {
2310                         uint32_t _flags_save_string = ndr->flags;
2311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2312                         if (r->servername) {
2313                                 uint32_t _relative_save_offset;
2314                                 _relative_save_offset = ndr->offset;
2315                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
2316                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2317                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
2318                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
2319                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
2320                                 ndr->offset = _relative_save_offset;
2321                         }
2322                         ndr->flags = _flags_save_string;
2323                 }
2324         }
2325         return NDR_ERR_SUCCESS;
2326 }
2327
2328 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
2329 {
2330         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
2331         ndr->depth++;
2332         ndr_print_ptr(ndr, "printername", r->printername);
2333         ndr->depth++;
2334         if (r->printername) {
2335                 ndr_print_string(ndr, "printername", r->printername);
2336         }
2337         ndr->depth--;
2338         ndr_print_ptr(ndr, "servername", r->servername);
2339         ndr->depth++;
2340         if (r->servername) {
2341                 ndr_print_string(ndr, "servername", r->servername);
2342         }
2343         ndr->depth--;
2344         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2345         ndr->depth--;
2346 }
2347
2348 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo4(const struct spoolss_PrinterInfo4 *r, struct smb_iconv_convenience *ic, int flags)
2349 {
2350         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo4, ic);
2351 }
2352
2353 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
2354 {
2355         if (ndr_flags & NDR_SCALARS) {
2356                 NDR_CHECK(ndr_push_align(ndr, 4));
2357                 {
2358                         uint32_t _flags_save_string = ndr->flags;
2359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2360                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2361                         ndr->flags = _flags_save_string;
2362                 }
2363                 {
2364                         uint32_t _flags_save_string = ndr->flags;
2365                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2366                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
2367                         ndr->flags = _flags_save_string;
2368                 }
2369                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2370                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
2371                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
2372         }
2373         if (ndr_flags & NDR_BUFFERS) {
2374                 {
2375                         uint32_t _flags_save_string = ndr->flags;
2376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2377                         if (r->printername) {
2378                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
2379                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2380                         }
2381                         ndr->flags = _flags_save_string;
2382                 }
2383                 {
2384                         uint32_t _flags_save_string = ndr->flags;
2385                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2386                         if (r->portname) {
2387                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
2388                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
2389                         }
2390                         ndr->flags = _flags_save_string;
2391                 }
2392         }
2393         return NDR_ERR_SUCCESS;
2394 }
2395
2396 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
2397 {
2398         uint32_t _ptr_printername;
2399         TALLOC_CTX *_mem_save_printername_0;
2400         uint32_t _ptr_portname;
2401         TALLOC_CTX *_mem_save_portname_0;
2402         if (ndr_flags & NDR_SCALARS) {
2403                 NDR_CHECK(ndr_pull_align(ndr, 4));
2404                 {
2405                         uint32_t _flags_save_string = ndr->flags;
2406                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2407                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2408                         if (_ptr_printername) {
2409                                 NDR_PULL_ALLOC(ndr, r->printername);
2410                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2411                         } else {
2412                                 r->printername = NULL;
2413                         }
2414                         ndr->flags = _flags_save_string;
2415                 }
2416                 {
2417                         uint32_t _flags_save_string = ndr->flags;
2418                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2419                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
2420                         if (_ptr_portname) {
2421                                 NDR_PULL_ALLOC(ndr, r->portname);
2422                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
2423                         } else {
2424                                 r->portname = NULL;
2425                         }
2426                         ndr->flags = _flags_save_string;
2427                 }
2428                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2429                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
2430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
2431         }
2432         if (ndr_flags & NDR_BUFFERS) {
2433                 {
2434                         uint32_t _flags_save_string = ndr->flags;
2435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2436                         if (r->printername) {
2437                                 uint32_t _relative_save_offset;
2438                                 _relative_save_offset = ndr->offset;
2439                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2440                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2441                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2442                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2443                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2444                                 ndr->offset = _relative_save_offset;
2445                         }
2446                         ndr->flags = _flags_save_string;
2447                 }
2448                 {
2449                         uint32_t _flags_save_string = ndr->flags;
2450                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2451                         if (r->portname) {
2452                                 uint32_t _relative_save_offset;
2453                                 _relative_save_offset = ndr->offset;
2454                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
2455                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2456                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
2457                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
2458                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
2459                                 ndr->offset = _relative_save_offset;
2460                         }
2461                         ndr->flags = _flags_save_string;
2462                 }
2463         }
2464         return NDR_ERR_SUCCESS;
2465 }
2466
2467 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
2468 {
2469         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
2470         ndr->depth++;
2471         ndr_print_ptr(ndr, "printername", r->printername);
2472         ndr->depth++;
2473         if (r->printername) {
2474                 ndr_print_string(ndr, "printername", r->printername);
2475         }
2476         ndr->depth--;
2477         ndr_print_ptr(ndr, "portname", r->portname);
2478         ndr->depth++;
2479         if (r->portname) {
2480                 ndr_print_string(ndr, "portname", r->portname);
2481         }
2482         ndr->depth--;
2483         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2484         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
2485         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
2486         ndr->depth--;
2487 }
2488
2489 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo5(const struct spoolss_PrinterInfo5 *r, struct smb_iconv_convenience *ic, int flags)
2490 {
2491         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5, ic);
2492 }
2493
2494 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
2495 {
2496         if (ndr_flags & NDR_SCALARS) {
2497                 NDR_CHECK(ndr_push_align(ndr, 4));
2498                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
2499         }
2500         if (ndr_flags & NDR_BUFFERS) {
2501         }
2502         return NDR_ERR_SUCCESS;
2503 }
2504
2505 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2506 {
2507         if (ndr_flags & NDR_SCALARS) {
2508                 NDR_CHECK(ndr_pull_align(ndr, 4));
2509                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2510         }
2511         if (ndr_flags & NDR_BUFFERS) {
2512         }
2513         return NDR_ERR_SUCCESS;
2514 }
2515
2516 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2517 {
2518         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2519         ndr->depth++;
2520         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2521         ndr->depth--;
2522 }
2523
2524 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo6(const struct spoolss_PrinterInfo6 *r, struct smb_iconv_convenience *ic, int flags)
2525 {
2526         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo6, ic);
2527 }
2528
2529 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2530 {
2531         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2532         return NDR_ERR_SUCCESS;
2533 }
2534
2535 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2536 {
2537         uint32_t v;
2538         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2539         *r = v;
2540         return NDR_ERR_SUCCESS;
2541 }
2542
2543 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2544 {
2545         ndr_print_uint32(ndr, name, r);
2546         ndr->depth++;
2547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2552         ndr->depth--;
2553 }
2554
2555 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2556 {
2557         if (ndr_flags & NDR_SCALARS) {
2558                 NDR_CHECK(ndr_push_align(ndr, 4));
2559                 {
2560                         uint32_t _flags_save_string = ndr->flags;
2561                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2562                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2563                         ndr->flags = _flags_save_string;
2564                 }
2565                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2566         }
2567         if (ndr_flags & NDR_BUFFERS) {
2568                 {
2569                         uint32_t _flags_save_string = ndr->flags;
2570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2571                         if (r->guid) {
2572                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2573                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2574                         }
2575                         ndr->flags = _flags_save_string;
2576                 }
2577         }
2578         return NDR_ERR_SUCCESS;
2579 }
2580
2581 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2582 {
2583         uint32_t _ptr_guid;
2584         TALLOC_CTX *_mem_save_guid_0;
2585         if (ndr_flags & NDR_SCALARS) {
2586                 NDR_CHECK(ndr_pull_align(ndr, 4));
2587                 {
2588                         uint32_t _flags_save_string = ndr->flags;
2589                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2590                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2591                         if (_ptr_guid) {
2592                                 NDR_PULL_ALLOC(ndr, r->guid);
2593                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2594                         } else {
2595                                 r->guid = NULL;
2596                         }
2597                         ndr->flags = _flags_save_string;
2598                 }
2599                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2600         }
2601         if (ndr_flags & NDR_BUFFERS) {
2602                 {
2603                         uint32_t _flags_save_string = ndr->flags;
2604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2605                         if (r->guid) {
2606                                 uint32_t _relative_save_offset;
2607                                 _relative_save_offset = ndr->offset;
2608                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2609                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2610                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2611                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2612                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2613                                 ndr->offset = _relative_save_offset;
2614                         }
2615                         ndr->flags = _flags_save_string;
2616                 }
2617         }
2618         return NDR_ERR_SUCCESS;
2619 }
2620
2621 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2622 {
2623         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2624         ndr->depth++;
2625         ndr_print_ptr(ndr, "guid", r->guid);
2626         ndr->depth++;
2627         if (r->guid) {
2628                 ndr_print_string(ndr, "guid", r->guid);
2629         }
2630         ndr->depth--;
2631         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2632         ndr->depth--;
2633 }
2634
2635 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo7(const struct spoolss_PrinterInfo7 *r, struct smb_iconv_convenience *ic, int flags)
2636 {
2637         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo7, ic);
2638 }
2639
2640 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2641 {
2642         if (ndr_flags & NDR_SCALARS) {
2643                 NDR_CHECK(ndr_push_align(ndr, 4));
2644                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2645         }
2646         if (ndr_flags & NDR_BUFFERS) {
2647                 if (r->devmode) {
2648                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2649                         {
2650                                 struct ndr_push *_ndr_devmode;
2651                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2652                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2653                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2654                         }
2655                 }
2656         }
2657         return NDR_ERR_SUCCESS;
2658 }
2659
2660 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2661 {
2662         uint32_t _ptr_devmode;
2663         TALLOC_CTX *_mem_save_devmode_0;
2664         if (ndr_flags & NDR_SCALARS) {
2665                 NDR_CHECK(ndr_pull_align(ndr, 4));
2666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2667                 if (_ptr_devmode) {
2668                         NDR_PULL_ALLOC(ndr, r->devmode);
2669                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2670                 } else {
2671                         r->devmode = NULL;
2672                 }
2673         }
2674         if (ndr_flags & NDR_BUFFERS) {
2675                 if (r->devmode) {
2676                         uint32_t _relative_save_offset;
2677                         _relative_save_offset = ndr->offset;
2678                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2679                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2680                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2681                         {
2682                                 struct ndr_pull *_ndr_devmode;
2683                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2684                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2685                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2686                         }
2687                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2688                         ndr->offset = _relative_save_offset;
2689                 }
2690         }
2691         return NDR_ERR_SUCCESS;
2692 }
2693
2694 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2695 {
2696         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2697         ndr->depth++;
2698         ndr_print_ptr(ndr, "devmode", r->devmode);
2699         ndr->depth++;
2700         if (r->devmode) {
2701                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2702         }
2703         ndr->depth--;
2704         ndr->depth--;
2705 }
2706
2707 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2708 {
2709         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2710         if (ndr_flags & NDR_SCALARS) {
2711                 int level = ndr_push_get_switch_value(ndr, r);
2712                 switch (level) {
2713                         case 0: {
2714                                 NDR_CHECK(ndr_push_align(ndr, 4));
2715                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2716                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2717                         break; }
2718
2719                         case 1: {
2720                                 NDR_CHECK(ndr_push_align(ndr, 4));
2721                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2722                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2723                         break; }
2724
2725                         case 2: {
2726                                 NDR_CHECK(ndr_push_align(ndr, 4));
2727                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2728                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2729                         break; }
2730
2731                         case 3: {
2732                                 NDR_CHECK(ndr_push_align(ndr, 4));
2733                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2734                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2735                         break; }
2736
2737                         case 4: {
2738                                 NDR_CHECK(ndr_push_align(ndr, 4));
2739                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2740                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2741                         break; }
2742
2743                         case 5: {
2744                                 NDR_CHECK(ndr_push_align(ndr, 4));
2745                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2746                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2747                         break; }
2748
2749                         case 6: {
2750                                 NDR_CHECK(ndr_push_align(ndr, 4));
2751                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2752                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2753                         break; }
2754
2755                         case 7: {
2756                                 NDR_CHECK(ndr_push_align(ndr, 4));
2757                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2758                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2759                         break; }
2760
2761                         case 8: {
2762                                 NDR_CHECK(ndr_push_align(ndr, 4));
2763                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2764                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2765                         break; }
2766
2767                         case 9: {
2768                                 NDR_CHECK(ndr_push_align(ndr, 4));
2769                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2770                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2771                         break; }
2772
2773                         default: {
2774                         break; }
2775
2776                 }
2777         }
2778         if (ndr_flags & NDR_BUFFERS) {
2779                 int level = ndr_push_get_switch_value(ndr, r);
2780                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2781                 switch (level) {
2782                         case 0:
2783                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2784                         break;
2785
2786                         case 1:
2787                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2788                         break;
2789
2790                         case 2:
2791                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2792                         break;
2793
2794                         case 3:
2795                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2796                         break;
2797
2798                         case 4:
2799                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2800                         break;
2801
2802                         case 5:
2803                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2804                         break;
2805
2806                         case 6:
2807                         break;
2808
2809                         case 7:
2810                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2811                         break;
2812
2813                         case 8:
2814                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2815                         break;
2816
2817                         case 9:
2818                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2819                         break;
2820
2821                         default:
2822                         break;
2823
2824                 }
2825         }
2826         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2827         return NDR_ERR_SUCCESS;
2828 }
2829
2830 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2831 {
2832         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2833         int level;
2834         level = ndr_pull_get_switch_value(ndr, r);
2835         if (ndr_flags & NDR_SCALARS) {
2836                 switch (level) {
2837                         case 0: {
2838                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2839                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2840                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2841                         break; }
2842
2843                         case 1: {
2844                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2845                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2846                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2847                         break; }
2848
2849                         case 2: {
2850                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2851                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2852                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2853                         break; }
2854
2855                         case 3: {
2856                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2857                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2858                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2859                         break; }
2860
2861                         case 4: {
2862                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2863                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2864                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2865                         break; }
2866
2867                         case 5: {
2868                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2869                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2870                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2871                         break; }
2872
2873                         case 6: {
2874                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2875                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2876                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2877                         break; }
2878
2879                         case 7: {
2880                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2881                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2882                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2883                         break; }
2884
2885                         case 8: {
2886                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2887                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2888                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2889                         break; }
2890
2891                         case 9: {
2892                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2893                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2894                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2895                         break; }
2896
2897                         default: {
2898                         break; }
2899
2900                 }
2901         }
2902         if (ndr_flags & NDR_BUFFERS) {
2903                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2904                 switch (level) {
2905                         case 0:
2906                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2907                         break;
2908
2909                         case 1:
2910                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2911                         break;
2912
2913                         case 2:
2914                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2915                         break;
2916
2917                         case 3:
2918                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2919                         break;
2920
2921                         case 4:
2922                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2923                         break;
2924
2925                         case 5:
2926                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2927                         break;
2928
2929                         case 6:
2930                         break;
2931
2932                         case 7:
2933                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2934                         break;
2935
2936                         case 8:
2937                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2938                         break;
2939
2940                         case 9:
2941                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2942                         break;
2943
2944                         default:
2945                         break;
2946
2947                 }
2948         }
2949         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2950         return NDR_ERR_SUCCESS;
2951 }
2952
2953 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2954 {
2955         int level;
2956         level = ndr_print_get_switch_value(ndr, r);
2957         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2958         switch (level) {
2959                 case 0:
2960                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2961                 break;
2962
2963                 case 1:
2964                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2965                 break;
2966
2967                 case 2:
2968                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2969                 break;
2970
2971                 case 3:
2972                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2973                 break;
2974
2975                 case 4:
2976                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2977                 break;
2978
2979                 case 5:
2980                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2981                 break;
2982
2983                 case 6:
2984                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2985                 break;
2986
2987                 case 7:
2988                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2989                 break;
2990
2991                 case 8:
2992                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2993                 break;
2994
2995                 case 9:
2996                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2997                 break;
2998
2999                 default:
3000                 break;
3001
3002         }
3003 }
3004
3005 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo(const union spoolss_PrinterInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
3006 {
3007         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo, ic);
3008 }
3009
3010 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
3011 {
3012         if (ndr_flags & NDR_SCALARS) {
3013                 NDR_CHECK(ndr_push_align(ndr, 4));
3014                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3015                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
3016         }
3017         if (ndr_flags & NDR_BUFFERS) {
3018                 if (r->devmode) {
3019                         {
3020                                 struct ndr_push *_ndr_devmode;
3021                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3022                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3023                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3024                         }
3025                 }
3026         }
3027         return NDR_ERR_SUCCESS;
3028 }
3029
3030 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
3031 {
3032         uint32_t _ptr_devmode;
3033         TALLOC_CTX *_mem_save_devmode_0;
3034         if (ndr_flags & NDR_SCALARS) {
3035                 NDR_CHECK(ndr_pull_align(ndr, 4));
3036                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
3037                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3038                 if (_ptr_devmode) {
3039                         NDR_PULL_ALLOC(ndr, r->devmode);
3040                 } else {
3041                         r->devmode = NULL;
3042                 }
3043         }
3044         if (ndr_flags & NDR_BUFFERS) {
3045                 if (r->devmode) {
3046                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3047                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3048                         {
3049                                 struct ndr_pull *_ndr_devmode;
3050                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
3051                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3052                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
3053                         }
3054                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3055                 }
3056         }
3057         return NDR_ERR_SUCCESS;
3058 }
3059
3060 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
3061 {
3062         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
3063         ndr->depth++;
3064         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);
3065         ndr_print_ptr(ndr, "devmode", r->devmode);
3066         ndr->depth++;
3067         if (r->devmode) {
3068                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3069         }
3070         ndr->depth--;
3071         ndr->depth--;
3072 }
3073
3074 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
3075 {
3076         if (ndr_flags & NDR_SCALARS) {
3077                 NDR_CHECK(ndr_push_align(ndr, 4));
3078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3079                 {
3080                         uint32_t _flags_save_string = ndr->flags;
3081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3082                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3083                         ndr->flags = _flags_save_string;
3084                 }
3085                 {
3086                         uint32_t _flags_save_string = ndr->flags;
3087                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3088                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3089                         ndr->flags = _flags_save_string;
3090                 }
3091                 {
3092                         uint32_t _flags_save_string = ndr->flags;
3093                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3094                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3095                         ndr->flags = _flags_save_string;
3096                 }
3097                 {
3098                         uint32_t _flags_save_string = ndr->flags;
3099                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3100                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3101                         ndr->flags = _flags_save_string;
3102                 }
3103                 {
3104                         uint32_t _flags_save_string = ndr->flags;
3105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3106                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3107                         ndr->flags = _flags_save_string;
3108                 }
3109                 {
3110                         uint32_t _flags_save_string = ndr->flags;
3111                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3112                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3113                         ndr->flags = _flags_save_string;
3114                 }
3115                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3120                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3121         }
3122         if (ndr_flags & NDR_BUFFERS) {
3123                 {
3124                         uint32_t _flags_save_string = ndr->flags;
3125                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3126                         if (r->printer_name) {
3127                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3128                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3129                         }
3130                         ndr->flags = _flags_save_string;
3131                 }
3132                 {
3133                         uint32_t _flags_save_string = ndr->flags;
3134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3135                         if (r->server_name) {
3136                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3137                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3138                         }
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                         if (r->user_name) {
3145                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3146                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3147                         }
3148                         ndr->flags = _flags_save_string;
3149                 }
3150                 {
3151                         uint32_t _flags_save_string = ndr->flags;
3152                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3153                         if (r->document_name) {
3154                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3155                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3156                         }
3157                         ndr->flags = _flags_save_string;
3158                 }
3159                 {
3160                         uint32_t _flags_save_string = ndr->flags;
3161                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3162                         if (r->data_type) {
3163                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3164                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3165                         }
3166                         ndr->flags = _flags_save_string;
3167                 }
3168                 {
3169                         uint32_t _flags_save_string = ndr->flags;
3170                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3171                         if (r->text_status) {
3172                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3173                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3174                         }
3175                         ndr->flags = _flags_save_string;
3176                 }
3177         }
3178         return NDR_ERR_SUCCESS;
3179 }
3180
3181 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
3182 {
3183         uint32_t _ptr_printer_name;
3184         TALLOC_CTX *_mem_save_printer_name_0;
3185         uint32_t _ptr_server_name;
3186         TALLOC_CTX *_mem_save_server_name_0;
3187         uint32_t _ptr_user_name;
3188         TALLOC_CTX *_mem_save_user_name_0;
3189         uint32_t _ptr_document_name;
3190         TALLOC_CTX *_mem_save_document_name_0;
3191         uint32_t _ptr_data_type;
3192         TALLOC_CTX *_mem_save_data_type_0;
3193         uint32_t _ptr_text_status;
3194         TALLOC_CTX *_mem_save_text_status_0;
3195         if (ndr_flags & NDR_SCALARS) {
3196                 NDR_CHECK(ndr_pull_align(ndr, 4));
3197                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3198                 {
3199                         uint32_t _flags_save_string = ndr->flags;
3200                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3201                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3202                         if (_ptr_printer_name) {
3203                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3204                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3205                         } else {
3206                                 r->printer_name = NULL;
3207                         }
3208                         ndr->flags = _flags_save_string;
3209                 }
3210                 {
3211                         uint32_t _flags_save_string = ndr->flags;
3212                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3213                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3214                         if (_ptr_server_name) {
3215                                 NDR_PULL_ALLOC(ndr, r->server_name);
3216                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3217                         } else {
3218                                 r->server_name = NULL;
3219                         }
3220                         ndr->flags = _flags_save_string;
3221                 }
3222                 {
3223                         uint32_t _flags_save_string = ndr->flags;
3224                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3225                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3226                         if (_ptr_user_name) {
3227                                 NDR_PULL_ALLOC(ndr, r->user_name);
3228                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3229                         } else {
3230                                 r->user_name = NULL;
3231                         }
3232                         ndr->flags = _flags_save_string;
3233                 }
3234                 {
3235                         uint32_t _flags_save_string = ndr->flags;
3236                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3237                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3238                         if (_ptr_document_name) {
3239                                 NDR_PULL_ALLOC(ndr, r->document_name);
3240                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3241                         } else {
3242                                 r->document_name = NULL;
3243                         }
3244                         ndr->flags = _flags_save_string;
3245                 }
3246                 {
3247                         uint32_t _flags_save_string = ndr->flags;
3248                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3249                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3250                         if (_ptr_data_type) {
3251                                 NDR_PULL_ALLOC(ndr, r->data_type);
3252                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3253                         } else {
3254                                 r->data_type = NULL;
3255                         }
3256                         ndr->flags = _flags_save_string;
3257                 }
3258                 {
3259                         uint32_t _flags_save_string = ndr->flags;
3260                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3261                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3262                         if (_ptr_text_status) {
3263                                 NDR_PULL_ALLOC(ndr, r->text_status);
3264                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3265                         } else {
3266                                 r->text_status = NULL;
3267                         }
3268                         ndr->flags = _flags_save_string;
3269                 }
3270                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3271                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3272                 if (r->priority > 99) {
3273                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3274                 }
3275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3277                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3278                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3279         }
3280         if (ndr_flags & NDR_BUFFERS) {
3281                 {
3282                         uint32_t _flags_save_string = ndr->flags;
3283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3284                         if (r->printer_name) {
3285                                 uint32_t _relative_save_offset;
3286                                 _relative_save_offset = ndr->offset;
3287                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3288                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3289                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3290                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3291                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3292                                 ndr->offset = _relative_save_offset;
3293                         }
3294                         ndr->flags = _flags_save_string;
3295                 }
3296                 {
3297                         uint32_t _flags_save_string = ndr->flags;
3298                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3299                         if (r->server_name) {
3300                                 uint32_t _relative_save_offset;
3301                                 _relative_save_offset = ndr->offset;
3302                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3303                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3304                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3305                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3306                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3307                                 ndr->offset = _relative_save_offset;
3308                         }
3309                         ndr->flags = _flags_save_string;
3310                 }
3311                 {
3312                         uint32_t _flags_save_string = ndr->flags;
3313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3314                         if (r->user_name) {
3315                                 uint32_t _relative_save_offset;
3316                                 _relative_save_offset = ndr->offset;
3317                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3318                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3319                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3320                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3321                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3322                                 ndr->offset = _relative_save_offset;
3323                         }
3324                         ndr->flags = _flags_save_string;
3325                 }
3326                 {
3327                         uint32_t _flags_save_string = ndr->flags;
3328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3329                         if (r->document_name) {
3330                                 uint32_t _relative_save_offset;
3331                                 _relative_save_offset = ndr->offset;
3332                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3333                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3334                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3335                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3336                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3337                                 ndr->offset = _relative_save_offset;
3338                         }
3339                         ndr->flags = _flags_save_string;
3340                 }
3341                 {
3342                         uint32_t _flags_save_string = ndr->flags;
3343                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3344                         if (r->data_type) {
3345                                 uint32_t _relative_save_offset;
3346                                 _relative_save_offset = ndr->offset;
3347                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3348                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3349                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3350                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3351                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3352                                 ndr->offset = _relative_save_offset;
3353                         }
3354                         ndr->flags = _flags_save_string;
3355                 }
3356                 {
3357                         uint32_t _flags_save_string = ndr->flags;
3358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3359                         if (r->text_status) {
3360                                 uint32_t _relative_save_offset;
3361                                 _relative_save_offset = ndr->offset;
3362                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3363                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3364                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3365                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3366                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3367                                 ndr->offset = _relative_save_offset;
3368                         }
3369                         ndr->flags = _flags_save_string;
3370                 }
3371         }
3372         return NDR_ERR_SUCCESS;
3373 }
3374
3375 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
3376 {
3377         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
3378         ndr->depth++;
3379         ndr_print_uint32(ndr, "job_id", r->job_id);
3380         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3381         ndr->depth++;
3382         if (r->printer_name) {
3383                 ndr_print_string(ndr, "printer_name", r->printer_name);
3384         }
3385         ndr->depth--;
3386         ndr_print_ptr(ndr, "server_name", r->server_name);
3387         ndr->depth++;
3388         if (r->server_name) {
3389                 ndr_print_string(ndr, "server_name", r->server_name);
3390         }
3391         ndr->depth--;
3392         ndr_print_ptr(ndr, "user_name", r->user_name);
3393         ndr->depth++;
3394         if (r->user_name) {
3395                 ndr_print_string(ndr, "user_name", r->user_name);
3396         }
3397         ndr->depth--;
3398         ndr_print_ptr(ndr, "document_name", r->document_name);
3399         ndr->depth++;
3400         if (r->document_name) {
3401                 ndr_print_string(ndr, "document_name", r->document_name);
3402         }
3403         ndr->depth--;
3404         ndr_print_ptr(ndr, "data_type", r->data_type);
3405         ndr->depth++;
3406         if (r->data_type) {
3407                 ndr_print_string(ndr, "data_type", r->data_type);
3408         }
3409         ndr->depth--;
3410         ndr_print_ptr(ndr, "text_status", r->text_status);
3411         ndr->depth++;
3412         if (r->text_status) {
3413                 ndr_print_string(ndr, "text_status", r->text_status);
3414         }
3415         ndr->depth--;
3416         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3417         ndr_print_uint32(ndr, "priority", r->priority);
3418         ndr_print_uint32(ndr, "position", r->position);
3419         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3420         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3421         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3422         ndr->depth--;
3423 }
3424
3425 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
3426 {
3427         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
3428 }
3429
3430 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
3431 {
3432         if (ndr_flags & NDR_SCALARS) {
3433                 NDR_CHECK(ndr_push_align(ndr, 4));
3434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3435                 {
3436                         uint32_t _flags_save_string = ndr->flags;
3437                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3438                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3439                         ndr->flags = _flags_save_string;
3440                 }
3441                 {
3442                         uint32_t _flags_save_string = ndr->flags;
3443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3444                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3445                         ndr->flags = _flags_save_string;
3446                 }
3447                 {
3448                         uint32_t _flags_save_string = ndr->flags;
3449                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3450                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3451                         ndr->flags = _flags_save_string;
3452                 }
3453                 {
3454                         uint32_t _flags_save_string = ndr->flags;
3455                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3456                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3457                         ndr->flags = _flags_save_string;
3458                 }
3459                 {
3460                         uint32_t _flags_save_string = ndr->flags;
3461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3462                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3463                         ndr->flags = _flags_save_string;
3464                 }
3465                 {
3466                         uint32_t _flags_save_string = ndr->flags;
3467                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3468                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3469                         ndr->flags = _flags_save_string;
3470                 }
3471                 {
3472                         uint32_t _flags_save_string = ndr->flags;
3473                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3474                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3475                         ndr->flags = _flags_save_string;
3476                 }
3477                 {
3478                         uint32_t _flags_save_string = ndr->flags;
3479                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3480                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3481                         ndr->flags = _flags_save_string;
3482                 }
3483                 {
3484                         uint32_t _flags_save_string = ndr->flags;
3485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3486                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3487                         ndr->flags = _flags_save_string;
3488                 }
3489                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3490                 {
3491                         uint32_t _flags_save_string = ndr->flags;
3492                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3493                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3494                         ndr->flags = _flags_save_string;
3495                 }
3496                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3497                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3498                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3499                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3500                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3501                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3502                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3503                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3504                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3505                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3506                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3507         }
3508         if (ndr_flags & NDR_BUFFERS) {
3509                 {
3510                         uint32_t _flags_save_string = ndr->flags;
3511                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3512                         if (r->printer_name) {
3513                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3514                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3515                         }
3516                         ndr->flags = _flags_save_string;
3517                 }
3518                 {
3519                         uint32_t _flags_save_string = ndr->flags;
3520                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3521                         if (r->server_name) {
3522                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3523                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3524                         }
3525                         ndr->flags = _flags_save_string;
3526                 }
3527                 {
3528                         uint32_t _flags_save_string = ndr->flags;
3529                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3530                         if (r->user_name) {
3531                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3532                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3533                         }
3534                         ndr->flags = _flags_save_string;
3535                 }
3536                 {
3537                         uint32_t _flags_save_string = ndr->flags;
3538                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3539                         if (r->document_name) {
3540                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3541                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3542                         }
3543                         ndr->flags = _flags_save_string;
3544                 }
3545                 {
3546                         uint32_t _flags_save_string = ndr->flags;
3547                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3548                         if (r->notify_name) {
3549                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3550                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3551                         }
3552                         ndr->flags = _flags_save_string;
3553                 }
3554                 {
3555                         uint32_t _flags_save_string = ndr->flags;
3556                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3557                         if (r->data_type) {
3558                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3559                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3560                         }
3561                         ndr->flags = _flags_save_string;
3562                 }
3563                 {
3564                         uint32_t _flags_save_string = ndr->flags;
3565                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3566                         if (r->print_processor) {
3567                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3568                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3569                         }
3570                         ndr->flags = _flags_save_string;
3571                 }
3572                 {
3573                         uint32_t _flags_save_string = ndr->flags;
3574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3575                         if (r->parameters) {
3576                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3577                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3578                         }
3579                         ndr->flags = _flags_save_string;
3580                 }
3581                 {
3582                         uint32_t _flags_save_string = ndr->flags;
3583                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3584                         if (r->driver_name) {
3585                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3586                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3587                         }
3588                         ndr->flags = _flags_save_string;
3589                 }
3590                 if (r->devmode) {
3591                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3592                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3593                 }
3594                 {
3595                         uint32_t _flags_save_string = ndr->flags;
3596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3597                         if (r->text_status) {
3598                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3599                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3600                         }
3601                         ndr->flags = _flags_save_string;
3602                 }
3603                 if (r->secdesc) {
3604                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3605                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3606                 }
3607         }
3608         return NDR_ERR_SUCCESS;
3609 }
3610
3611 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3612 {
3613         uint32_t _ptr_printer_name;
3614         TALLOC_CTX *_mem_save_printer_name_0;
3615         uint32_t _ptr_server_name;
3616         TALLOC_CTX *_mem_save_server_name_0;
3617         uint32_t _ptr_user_name;
3618         TALLOC_CTX *_mem_save_user_name_0;
3619         uint32_t _ptr_document_name;
3620         TALLOC_CTX *_mem_save_document_name_0;
3621         uint32_t _ptr_notify_name;
3622         TALLOC_CTX *_mem_save_notify_name_0;
3623         uint32_t _ptr_data_type;
3624         TALLOC_CTX *_mem_save_data_type_0;
3625         uint32_t _ptr_print_processor;
3626         TALLOC_CTX *_mem_save_print_processor_0;
3627         uint32_t _ptr_parameters;
3628         TALLOC_CTX *_mem_save_parameters_0;
3629         uint32_t _ptr_driver_name;
3630         TALLOC_CTX *_mem_save_driver_name_0;
3631         uint32_t _ptr_devmode;
3632         TALLOC_CTX *_mem_save_devmode_0;
3633         uint32_t _ptr_text_status;
3634         TALLOC_CTX *_mem_save_text_status_0;
3635         uint32_t _ptr_secdesc;
3636         TALLOC_CTX *_mem_save_secdesc_0;
3637         if (ndr_flags & NDR_SCALARS) {
3638                 NDR_CHECK(ndr_pull_align(ndr, 4));
3639                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3640                 {
3641                         uint32_t _flags_save_string = ndr->flags;
3642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3643                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3644                         if (_ptr_printer_name) {
3645                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3646                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3647                         } else {
3648                                 r->printer_name = NULL;
3649                         }
3650                         ndr->flags = _flags_save_string;
3651                 }
3652                 {
3653                         uint32_t _flags_save_string = ndr->flags;
3654                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3655                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3656                         if (_ptr_server_name) {
3657                                 NDR_PULL_ALLOC(ndr, r->server_name);
3658                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3659                         } else {
3660                                 r->server_name = NULL;
3661                         }
3662                         ndr->flags = _flags_save_string;
3663                 }
3664                 {
3665                         uint32_t _flags_save_string = ndr->flags;
3666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3667                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3668                         if (_ptr_user_name) {
3669                                 NDR_PULL_ALLOC(ndr, r->user_name);
3670                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3671                         } else {
3672                                 r->user_name = NULL;
3673                         }
3674                         ndr->flags = _flags_save_string;
3675                 }
3676                 {
3677                         uint32_t _flags_save_string = ndr->flags;
3678                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3679                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3680                         if (_ptr_document_name) {
3681                                 NDR_PULL_ALLOC(ndr, r->document_name);
3682                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3683                         } else {
3684                                 r->document_name = NULL;
3685                         }
3686                         ndr->flags = _flags_save_string;
3687                 }
3688                 {
3689                         uint32_t _flags_save_string = ndr->flags;
3690                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3691                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3692                         if (_ptr_notify_name) {
3693                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3694                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3695                         } else {
3696                                 r->notify_name = NULL;
3697                         }
3698                         ndr->flags = _flags_save_string;
3699                 }
3700                 {
3701                         uint32_t _flags_save_string = ndr->flags;
3702                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3703                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3704                         if (_ptr_data_type) {
3705                                 NDR_PULL_ALLOC(ndr, r->data_type);
3706                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3707                         } else {
3708                                 r->data_type = NULL;
3709                         }
3710                         ndr->flags = _flags_save_string;
3711                 }
3712                 {
3713                         uint32_t _flags_save_string = ndr->flags;
3714                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3715                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3716                         if (_ptr_print_processor) {
3717                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3718                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3719                         } else {
3720                                 r->print_processor = NULL;
3721                         }
3722                         ndr->flags = _flags_save_string;
3723                 }
3724                 {
3725                         uint32_t _flags_save_string = ndr->flags;
3726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3727                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3728                         if (_ptr_parameters) {
3729                                 NDR_PULL_ALLOC(ndr, r->parameters);
3730                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3731                         } else {
3732                                 r->parameters = NULL;
3733                         }
3734                         ndr->flags = _flags_save_string;
3735                 }
3736                 {
3737                         uint32_t _flags_save_string = ndr->flags;
3738                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3739                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3740                         if (_ptr_driver_name) {
3741                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3742                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3743                         } else {
3744                                 r->driver_name = NULL;
3745                         }
3746                         ndr->flags = _flags_save_string;
3747                 }
3748                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3749                 if (_ptr_devmode) {
3750                         NDR_PULL_ALLOC(ndr, r->devmode);
3751                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3752                 } else {
3753                         r->devmode = NULL;
3754                 }
3755                 {
3756                         uint32_t _flags_save_string = ndr->flags;
3757                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3758                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3759                         if (_ptr_text_status) {
3760                                 NDR_PULL_ALLOC(ndr, r->text_status);
3761                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3762                         } else {
3763                                 r->text_status = NULL;
3764                         }
3765                         ndr->flags = _flags_save_string;
3766                 }
3767                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3768                 if (_ptr_secdesc) {
3769                         NDR_PULL_ALLOC(ndr, r->secdesc);
3770                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3771                 } else {
3772                         r->secdesc = NULL;
3773                 }
3774                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3775                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3776                 if (r->priority > 99) {
3777                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3778                 }
3779                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3780                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3784                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3785                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3786                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3787         }
3788         if (ndr_flags & NDR_BUFFERS) {
3789                 {
3790                         uint32_t _flags_save_string = ndr->flags;
3791                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3792                         if (r->printer_name) {
3793                                 uint32_t _relative_save_offset;
3794                                 _relative_save_offset = ndr->offset;
3795                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3796                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3797                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3798                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3799                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3800                                 ndr->offset = _relative_save_offset;
3801                         }
3802                         ndr->flags = _flags_save_string;
3803                 }
3804                 {
3805                         uint32_t _flags_save_string = ndr->flags;
3806                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3807                         if (r->server_name) {
3808                                 uint32_t _relative_save_offset;
3809                                 _relative_save_offset = ndr->offset;
3810                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3811                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3812                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3813                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3814                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3815                                 ndr->offset = _relative_save_offset;
3816                         }
3817                         ndr->flags = _flags_save_string;
3818                 }
3819                 {
3820                         uint32_t _flags_save_string = ndr->flags;
3821                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3822                         if (r->user_name) {
3823                                 uint32_t _relative_save_offset;
3824                                 _relative_save_offset = ndr->offset;
3825                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3826                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3827                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3828                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3829                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3830                                 ndr->offset = _relative_save_offset;
3831                         }
3832                         ndr->flags = _flags_save_string;
3833                 }
3834                 {
3835                         uint32_t _flags_save_string = ndr->flags;
3836                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3837                         if (r->document_name) {
3838                                 uint32_t _relative_save_offset;
3839                                 _relative_save_offset = ndr->offset;
3840                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3841                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3842                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3843                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3844                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3845                                 ndr->offset = _relative_save_offset;
3846                         }
3847                         ndr->flags = _flags_save_string;
3848                 }
3849                 {
3850                         uint32_t _flags_save_string = ndr->flags;
3851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3852                         if (r->notify_name) {
3853                                 uint32_t _relative_save_offset;
3854                                 _relative_save_offset = ndr->offset;
3855                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3856                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3857                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3858                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3859                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3860                                 ndr->offset = _relative_save_offset;
3861                         }
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                         if (r->data_type) {
3868                                 uint32_t _relative_save_offset;
3869                                 _relative_save_offset = ndr->offset;
3870                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3871                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3872                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3873                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3874                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3875                                 ndr->offset = _relative_save_offset;
3876                         }
3877                         ndr->flags = _flags_save_string;
3878                 }
3879                 {
3880                         uint32_t _flags_save_string = ndr->flags;
3881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3882                         if (r->print_processor) {
3883                                 uint32_t _relative_save_offset;
3884                                 _relative_save_offset = ndr->offset;
3885                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
3886                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3887                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
3888                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
3889                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
3890                                 ndr->offset = _relative_save_offset;
3891                         }
3892                         ndr->flags = _flags_save_string;
3893                 }
3894                 {
3895                         uint32_t _flags_save_string = ndr->flags;
3896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3897                         if (r->parameters) {
3898                                 uint32_t _relative_save_offset;
3899                                 _relative_save_offset = ndr->offset;
3900                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
3901                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3902                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3903                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
3904                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3905                                 ndr->offset = _relative_save_offset;
3906                         }
3907                         ndr->flags = _flags_save_string;
3908                 }
3909                 {
3910                         uint32_t _flags_save_string = ndr->flags;
3911                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3912                         if (r->driver_name) {
3913                                 uint32_t _relative_save_offset;
3914                                 _relative_save_offset = ndr->offset;
3915                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
3916                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3917                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
3918                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
3919                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
3920                                 ndr->offset = _relative_save_offset;
3921                         }
3922                         ndr->flags = _flags_save_string;
3923                 }
3924                 if (r->devmode) {
3925                         uint32_t _relative_save_offset;
3926                         _relative_save_offset = ndr->offset;
3927                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
3928                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3929                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3930                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3931                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3932                         ndr->offset = _relative_save_offset;
3933                 }
3934                 {
3935                         uint32_t _flags_save_string = ndr->flags;
3936                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3937                         if (r->text_status) {
3938                                 uint32_t _relative_save_offset;
3939                                 _relative_save_offset = ndr->offset;
3940                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3941                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3942                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3943                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3944                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3945                                 ndr->offset = _relative_save_offset;
3946                         }
3947                         ndr->flags = _flags_save_string;
3948                 }
3949                 if (r->secdesc) {
3950                         uint32_t _relative_save_offset;
3951                         _relative_save_offset = ndr->offset;
3952                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
3953                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3954                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3955                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3956                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3957                         ndr->offset = _relative_save_offset;
3958                 }
3959         }
3960         return NDR_ERR_SUCCESS;
3961 }
3962
3963 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
3964 {
3965         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
3966         ndr->depth++;
3967         ndr_print_uint32(ndr, "job_id", r->job_id);
3968         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3969         ndr->depth++;
3970         if (r->printer_name) {
3971                 ndr_print_string(ndr, "printer_name", r->printer_name);
3972         }
3973         ndr->depth--;
3974         ndr_print_ptr(ndr, "server_name", r->server_name);
3975         ndr->depth++;
3976         if (r->server_name) {
3977                 ndr_print_string(ndr, "server_name", r->server_name);
3978         }
3979         ndr->depth--;
3980         ndr_print_ptr(ndr, "user_name", r->user_name);
3981         ndr->depth++;
3982         if (r->user_name) {
3983                 ndr_print_string(ndr, "user_name", r->user_name);
3984         }
3985         ndr->depth--;
3986         ndr_print_ptr(ndr, "document_name", r->document_name);
3987         ndr->depth++;
3988         if (r->document_name) {
3989                 ndr_print_string(ndr, "document_name", r->document_name);
3990         }
3991         ndr->depth--;
3992         ndr_print_ptr(ndr, "notify_name", r->notify_name);
3993         ndr->depth++;
3994         if (r->notify_name) {
3995                 ndr_print_string(ndr, "notify_name", r->notify_name);
3996         }
3997         ndr->depth--;
3998         ndr_print_ptr(ndr, "data_type", r->data_type);
3999         ndr->depth++;
4000         if (r->data_type) {
4001                 ndr_print_string(ndr, "data_type", r->data_type);
4002         }
4003         ndr->depth--;
4004         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4005         ndr->depth++;
4006         if (r->print_processor) {
4007                 ndr_print_string(ndr, "print_processor", r->print_processor);
4008         }
4009         ndr->depth--;
4010         ndr_print_ptr(ndr, "parameters", r->parameters);
4011         ndr->depth++;
4012         if (r->parameters) {
4013                 ndr_print_string(ndr, "parameters", r->parameters);
4014         }
4015         ndr->depth--;
4016         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4017         ndr->depth++;
4018         if (r->driver_name) {
4019                 ndr_print_string(ndr, "driver_name", r->driver_name);
4020         }
4021         ndr->depth--;
4022         ndr_print_ptr(ndr, "devmode", r->devmode);
4023         ndr->depth++;
4024         if (r->devmode) {
4025                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4026         }
4027         ndr->depth--;
4028         ndr_print_ptr(ndr, "text_status", r->text_status);
4029         ndr->depth++;
4030         if (r->text_status) {
4031                 ndr_print_string(ndr, "text_status", r->text_status);
4032         }
4033         ndr->depth--;
4034         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4035         ndr->depth++;
4036         if (r->secdesc) {
4037                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4038         }
4039         ndr->depth--;
4040         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4041         ndr_print_uint32(ndr, "priority", r->priority);
4042         ndr_print_uint32(ndr, "position", r->position);
4043         ndr_print_uint32(ndr, "start_time", r->start_time);
4044         ndr_print_uint32(ndr, "until_time", r->until_time);
4045         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4046         ndr_print_uint32(ndr, "size", r->size);
4047         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4048         ndr_print_uint32(ndr, "time", r->time);
4049         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4050         ndr->depth--;
4051 }
4052
4053 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
4054 {
4055         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
4056 }
4057
4058 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
4059 {
4060         if (ndr_flags & NDR_SCALARS) {
4061                 NDR_CHECK(ndr_push_align(ndr, 4));
4062                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
4064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
4065         }
4066         if (ndr_flags & NDR_BUFFERS) {
4067         }
4068         return NDR_ERR_SUCCESS;
4069 }
4070
4071 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
4072 {
4073         if (ndr_flags & NDR_SCALARS) {
4074                 NDR_CHECK(ndr_pull_align(ndr, 4));
4075                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
4077                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
4078         }
4079         if (ndr_flags & NDR_BUFFERS) {
4080         }
4081         return NDR_ERR_SUCCESS;
4082 }
4083
4084 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
4085 {
4086         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
4087         ndr->depth++;
4088         ndr_print_uint32(ndr, "job_id", r->job_id);
4089         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
4090         ndr_print_uint32(ndr, "reserved", r->reserved);
4091         ndr->depth--;
4092 }
4093
4094 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
4095 {
4096         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
4097 }
4098
4099 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
4100 {
4101         if (ndr_flags & NDR_SCALARS) {
4102                 NDR_CHECK(ndr_push_align(ndr, 4));
4103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4104                 {
4105                         uint32_t _flags_save_string = ndr->flags;
4106                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4107                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
4108                         ndr->flags = _flags_save_string;
4109                 }
4110                 {
4111                         uint32_t _flags_save_string = ndr->flags;
4112                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4113                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
4114                         ndr->flags = _flags_save_string;
4115                 }
4116                 {
4117                         uint32_t _flags_save_string = ndr->flags;
4118                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4119                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
4120                         ndr->flags = _flags_save_string;
4121                 }
4122                 {
4123                         uint32_t _flags_save_string = ndr->flags;
4124                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4125                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
4126                         ndr->flags = _flags_save_string;
4127                 }
4128                 {
4129                         uint32_t _flags_save_string = ndr->flags;
4130                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4131                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
4132                         ndr->flags = _flags_save_string;
4133                 }
4134                 {
4135                         uint32_t _flags_save_string = ndr->flags;
4136                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4137                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
4138                         ndr->flags = _flags_save_string;
4139                 }
4140                 {
4141                         uint32_t _flags_save_string = ndr->flags;
4142                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4143                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
4144                         ndr->flags = _flags_save_string;
4145                 }
4146                 {
4147                         uint32_t _flags_save_string = ndr->flags;
4148                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4149                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
4150                         ndr->flags = _flags_save_string;
4151                 }
4152                 {
4153                         uint32_t _flags_save_string = ndr->flags;
4154                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4155                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
4156                         ndr->flags = _flags_save_string;
4157                 }
4158                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
4159                 {
4160                         uint32_t _flags_save_string = ndr->flags;
4161                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4162                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
4163                         ndr->flags = _flags_save_string;
4164                 }
4165                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
4166                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4168                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4172                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4173                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4175                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
4177         }
4178         if (ndr_flags & NDR_BUFFERS) {
4179                 {
4180                         uint32_t _flags_save_string = ndr->flags;
4181                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4182                         if (r->printer_name) {
4183                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
4184                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
4185                         }
4186                         ndr->flags = _flags_save_string;
4187                 }
4188                 {
4189                         uint32_t _flags_save_string = ndr->flags;
4190                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4191                         if (r->server_name) {
4192                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
4193                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
4194                         }
4195                         ndr->flags = _flags_save_string;
4196                 }
4197                 {
4198                         uint32_t _flags_save_string = ndr->flags;
4199                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4200                         if (r->user_name) {
4201                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
4202                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
4203                         }
4204                         ndr->flags = _flags_save_string;
4205                 }
4206                 {
4207                         uint32_t _flags_save_string = ndr->flags;
4208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4209                         if (r->document_name) {
4210                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
4211                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
4212                         }
4213                         ndr->flags = _flags_save_string;
4214                 }
4215                 {
4216                         uint32_t _flags_save_string = ndr->flags;
4217                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4218                         if (r->notify_name) {
4219                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
4220                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
4221                         }
4222                         ndr->flags = _flags_save_string;
4223                 }
4224                 {
4225                         uint32_t _flags_save_string = ndr->flags;
4226                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4227                         if (r->data_type) {
4228                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
4229                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
4230                         }
4231                         ndr->flags = _flags_save_string;
4232                 }
4233                 {
4234                         uint32_t _flags_save_string = ndr->flags;
4235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4236                         if (r->print_processor) {
4237                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
4238                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
4239                         }
4240                         ndr->flags = _flags_save_string;
4241                 }
4242                 {
4243                         uint32_t _flags_save_string = ndr->flags;
4244                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4245                         if (r->parameters) {
4246                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
4247                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
4248                         }
4249                         ndr->flags = _flags_save_string;
4250                 }
4251                 {
4252                         uint32_t _flags_save_string = ndr->flags;
4253                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4254                         if (r->driver_name) {
4255                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
4256                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
4257                         }
4258                         ndr->flags = _flags_save_string;
4259                 }
4260                 if (r->devmode) {
4261                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
4262                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4263                 }
4264                 {
4265                         uint32_t _flags_save_string = ndr->flags;
4266                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4267                         if (r->text_status) {
4268                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
4269                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
4270                         }
4271                         ndr->flags = _flags_save_string;
4272                 }
4273                 if (r->secdesc) {
4274                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
4275                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4276                 }
4277         }
4278         return NDR_ERR_SUCCESS;
4279 }
4280
4281 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
4282 {
4283         uint32_t _ptr_printer_name;
4284         TALLOC_CTX *_mem_save_printer_name_0;
4285         uint32_t _ptr_server_name;
4286         TALLOC_CTX *_mem_save_server_name_0;
4287         uint32_t _ptr_user_name;
4288         TALLOC_CTX *_mem_save_user_name_0;
4289         uint32_t _ptr_document_name;
4290         TALLOC_CTX *_mem_save_document_name_0;
4291         uint32_t _ptr_notify_name;
4292         TALLOC_CTX *_mem_save_notify_name_0;
4293         uint32_t _ptr_data_type;
4294         TALLOC_CTX *_mem_save_data_type_0;
4295         uint32_t _ptr_print_processor;
4296         TALLOC_CTX *_mem_save_print_processor_0;
4297         uint32_t _ptr_parameters;
4298         TALLOC_CTX *_mem_save_parameters_0;
4299         uint32_t _ptr_driver_name;
4300         TALLOC_CTX *_mem_save_driver_name_0;
4301         uint32_t _ptr_devmode;
4302         TALLOC_CTX *_mem_save_devmode_0;
4303         uint32_t _ptr_text_status;
4304         TALLOC_CTX *_mem_save_text_status_0;
4305         uint32_t _ptr_secdesc;
4306         TALLOC_CTX *_mem_save_secdesc_0;
4307         if (ndr_flags & NDR_SCALARS) {
4308                 NDR_CHECK(ndr_pull_align(ndr, 4));
4309                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4310                 {
4311                         uint32_t _flags_save_string = ndr->flags;
4312                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4313                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4314                         if (_ptr_printer_name) {
4315                                 NDR_PULL_ALLOC(ndr, r->printer_name);
4316                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
4317                         } else {
4318                                 r->printer_name = NULL;
4319                         }
4320                         ndr->flags = _flags_save_string;
4321                 }
4322                 {
4323                         uint32_t _flags_save_string = ndr->flags;
4324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4325                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4326                         if (_ptr_server_name) {
4327                                 NDR_PULL_ALLOC(ndr, r->server_name);
4328                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
4329                         } else {
4330                                 r->server_name = NULL;
4331                         }
4332                         ndr->flags = _flags_save_string;
4333                 }
4334                 {
4335                         uint32_t _flags_save_string = ndr->flags;
4336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4337                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4338                         if (_ptr_user_name) {
4339                                 NDR_PULL_ALLOC(ndr, r->user_name);
4340                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
4341                         } else {
4342                                 r->user_name = NULL;
4343                         }
4344                         ndr->flags = _flags_save_string;
4345                 }
4346                 {
4347                         uint32_t _flags_save_string = ndr->flags;
4348                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4349                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4350                         if (_ptr_document_name) {
4351                                 NDR_PULL_ALLOC(ndr, r->document_name);
4352                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
4353                         } else {
4354                                 r->document_name = NULL;
4355                         }
4356                         ndr->flags = _flags_save_string;
4357                 }
4358                 {
4359                         uint32_t _flags_save_string = ndr->flags;
4360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4361                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4362                         if (_ptr_notify_name) {
4363                                 NDR_PULL_ALLOC(ndr, r->notify_name);
4364                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
4365                         } else {
4366                                 r->notify_name = NULL;
4367                         }
4368                         ndr->flags = _flags_save_string;
4369                 }
4370                 {
4371                         uint32_t _flags_save_string = ndr->flags;
4372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4373                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4374                         if (_ptr_data_type) {
4375                                 NDR_PULL_ALLOC(ndr, r->data_type);
4376                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
4377                         } else {
4378                                 r->data_type = NULL;
4379                         }
4380                         ndr->flags = _flags_save_string;
4381                 }
4382                 {
4383                         uint32_t _flags_save_string = ndr->flags;
4384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4385                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4386                         if (_ptr_print_processor) {
4387                                 NDR_PULL_ALLOC(ndr, r->print_processor);
4388                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
4389                         } else {
4390                                 r->print_processor = NULL;
4391                         }
4392                         ndr->flags = _flags_save_string;
4393                 }
4394                 {
4395                         uint32_t _flags_save_string = ndr->flags;
4396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4397                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4398                         if (_ptr_parameters) {
4399                                 NDR_PULL_ALLOC(ndr, r->parameters);
4400                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
4401                         } else {
4402                                 r->parameters = NULL;
4403                         }
4404                         ndr->flags = _flags_save_string;
4405                 }
4406                 {
4407                         uint32_t _flags_save_string = ndr->flags;
4408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4409                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4410                         if (_ptr_driver_name) {
4411                                 NDR_PULL_ALLOC(ndr, r->driver_name);
4412                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
4413                         } else {
4414                                 r->driver_name = NULL;
4415                         }
4416                         ndr->flags = _flags_save_string;
4417                 }
4418                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
4419                 if (_ptr_devmode) {
4420                         NDR_PULL_ALLOC(ndr, r->devmode);
4421                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
4422                 } else {
4423                         r->devmode = NULL;
4424                 }
4425                 {
4426                         uint32_t _flags_save_string = ndr->flags;
4427                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4428                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4429                         if (_ptr_text_status) {
4430                                 NDR_PULL_ALLOC(ndr, r->text_status);
4431                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
4432                         } else {
4433                                 r->text_status = NULL;
4434                         }
4435                         ndr->flags = _flags_save_string;
4436                 }
4437                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
4438                 if (_ptr_secdesc) {
4439                         NDR_PULL_ALLOC(ndr, r->secdesc);
4440                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
4441                 } else {
4442                         r->secdesc = NULL;
4443                 }
4444                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4446                 if (r->priority > 99) {
4447                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4448                 }
4449                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4454                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
4458         }
4459         if (ndr_flags & NDR_BUFFERS) {
4460                 {
4461                         uint32_t _flags_save_string = ndr->flags;
4462                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4463                         if (r->printer_name) {
4464                                 uint32_t _relative_save_offset;
4465                                 _relative_save_offset = ndr->offset;
4466                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
4467                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4468                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4469                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
4470                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4471                                 ndr->offset = _relative_save_offset;
4472                         }
4473                         ndr->flags = _flags_save_string;
4474                 }
4475                 {
4476                         uint32_t _flags_save_string = ndr->flags;
4477                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4478                         if (r->server_name) {
4479                                 uint32_t _relative_save_offset;
4480                                 _relative_save_offset = ndr->offset;
4481                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4482                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4483                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4484                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4485                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4486                                 ndr->offset = _relative_save_offset;
4487                         }
4488                         ndr->flags = _flags_save_string;
4489                 }
4490                 {
4491                         uint32_t _flags_save_string = ndr->flags;
4492                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4493                         if (r->user_name) {
4494                                 uint32_t _relative_save_offset;
4495                                 _relative_save_offset = ndr->offset;
4496                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4497                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4498                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4499                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4500                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4501                                 ndr->offset = _relative_save_offset;
4502                         }
4503                         ndr->flags = _flags_save_string;
4504                 }
4505                 {
4506                         uint32_t _flags_save_string = ndr->flags;
4507                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4508                         if (r->document_name) {
4509                                 uint32_t _relative_save_offset;
4510                                 _relative_save_offset = ndr->offset;
4511                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4512                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4513                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4514                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4515                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4516                                 ndr->offset = _relative_save_offset;
4517                         }
4518                         ndr->flags = _flags_save_string;
4519                 }
4520                 {
4521                         uint32_t _flags_save_string = ndr->flags;
4522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4523                         if (r->notify_name) {
4524                                 uint32_t _relative_save_offset;
4525                                 _relative_save_offset = ndr->offset;
4526                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4527                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4528                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4529                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4530                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4531                                 ndr->offset = _relative_save_offset;
4532                         }
4533                         ndr->flags = _flags_save_string;
4534                 }
4535                 {
4536                         uint32_t _flags_save_string = ndr->flags;
4537                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4538                         if (r->data_type) {
4539                                 uint32_t _relative_save_offset;
4540                                 _relative_save_offset = ndr->offset;
4541                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4542                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4543                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4544                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4545                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4546                                 ndr->offset = _relative_save_offset;
4547                         }
4548                         ndr->flags = _flags_save_string;
4549                 }
4550                 {
4551                         uint32_t _flags_save_string = ndr->flags;
4552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4553                         if (r->print_processor) {
4554                                 uint32_t _relative_save_offset;
4555                                 _relative_save_offset = ndr->offset;
4556                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4557                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4558                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4559                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4560                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4561                                 ndr->offset = _relative_save_offset;
4562                         }
4563                         ndr->flags = _flags_save_string;
4564                 }
4565                 {
4566                         uint32_t _flags_save_string = ndr->flags;
4567                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4568                         if (r->parameters) {
4569                                 uint32_t _relative_save_offset;
4570                                 _relative_save_offset = ndr->offset;
4571                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4572                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4573                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4574                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4575                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4576                                 ndr->offset = _relative_save_offset;
4577                         }
4578                         ndr->flags = _flags_save_string;
4579                 }
4580                 {
4581                         uint32_t _flags_save_string = ndr->flags;
4582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4583                         if (r->driver_name) {
4584                                 uint32_t _relative_save_offset;
4585                                 _relative_save_offset = ndr->offset;
4586                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4587                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4588                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4589                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4590                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4591                                 ndr->offset = _relative_save_offset;
4592                         }
4593                         ndr->flags = _flags_save_string;
4594                 }
4595                 if (r->devmode) {
4596                         uint32_t _relative_save_offset;
4597                         _relative_save_offset = ndr->offset;
4598                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4599                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4600                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4601                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4602                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4603                         ndr->offset = _relative_save_offset;
4604                 }
4605                 {
4606                         uint32_t _flags_save_string = ndr->flags;
4607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4608                         if (r->text_status) {
4609                                 uint32_t _relative_save_offset;
4610                                 _relative_save_offset = ndr->offset;
4611                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4612                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4613                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4614                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4615                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4616                                 ndr->offset = _relative_save_offset;
4617                         }
4618                         ndr->flags = _flags_save_string;
4619                 }
4620                 if (r->secdesc) {
4621                         uint32_t _relative_save_offset;
4622                         _relative_save_offset = ndr->offset;
4623                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4624                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4625                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4626                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4627                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4628                         ndr->offset = _relative_save_offset;
4629                 }
4630         }
4631         return NDR_ERR_SUCCESS;
4632 }
4633
4634 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4635 {
4636         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4637         ndr->depth++;
4638         ndr_print_uint32(ndr, "job_id", r->job_id);
4639         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4640         ndr->depth++;
4641         if (r->printer_name) {
4642                 ndr_print_string(ndr, "printer_name", r->printer_name);
4643         }
4644         ndr->depth--;
4645         ndr_print_ptr(ndr, "server_name", r->server_name);
4646         ndr->depth++;
4647         if (r->server_name) {
4648                 ndr_print_string(ndr, "server_name", r->server_name);
4649         }
4650         ndr->depth--;
4651         ndr_print_ptr(ndr, "user_name", r->user_name);
4652         ndr->depth++;
4653         if (r->user_name) {
4654                 ndr_print_string(ndr, "user_name", r->user_name);
4655         }
4656         ndr->depth--;
4657         ndr_print_ptr(ndr, "document_name", r->document_name);
4658         ndr->depth++;
4659         if (r->document_name) {
4660                 ndr_print_string(ndr, "document_name", r->document_name);
4661         }
4662         ndr->depth--;
4663         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4664         ndr->depth++;
4665         if (r->notify_name) {
4666                 ndr_print_string(ndr, "notify_name", r->notify_name);
4667         }
4668         ndr->depth--;
4669         ndr_print_ptr(ndr, "data_type", r->data_type);
4670         ndr->depth++;
4671         if (r->data_type) {
4672                 ndr_print_string(ndr, "data_type", r->data_type);
4673         }
4674         ndr->depth--;
4675         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4676         ndr->depth++;
4677         if (r->print_processor) {
4678                 ndr_print_string(ndr, "print_processor", r->print_processor);
4679         }
4680         ndr->depth--;
4681         ndr_print_ptr(ndr, "parameters", r->parameters);
4682         ndr->depth++;
4683         if (r->parameters) {
4684                 ndr_print_string(ndr, "parameters", r->parameters);
4685         }
4686         ndr->depth--;
4687         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4688         ndr->depth++;
4689         if (r->driver_name) {
4690                 ndr_print_string(ndr, "driver_name", r->driver_name);
4691         }
4692         ndr->depth--;
4693         ndr_print_ptr(ndr, "devmode", r->devmode);
4694         ndr->depth++;
4695         if (r->devmode) {
4696                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4697         }
4698         ndr->depth--;
4699         ndr_print_ptr(ndr, "text_status", r->text_status);
4700         ndr->depth++;
4701         if (r->text_status) {
4702                 ndr_print_string(ndr, "text_status", r->text_status);
4703         }
4704         ndr->depth--;
4705         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4706         ndr->depth++;
4707         if (r->secdesc) {
4708                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4709         }
4710         ndr->depth--;
4711         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4712         ndr_print_uint32(ndr, "priority", r->priority);
4713         ndr_print_uint32(ndr, "position", r->position);
4714         ndr_print_uint32(ndr, "start_time", r->start_time);
4715         ndr_print_uint32(ndr, "until_time", r->until_time);
4716         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4717         ndr_print_uint32(ndr, "size", r->size);
4718         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4719         ndr_print_uint32(ndr, "time", r->time);
4720         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4721         ndr_print_uint32(ndr, "size_high", r->size_high);
4722         ndr->depth--;
4723 }
4724
4725 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
4726 {
4727         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
4728 }
4729
4730 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4731 {
4732         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4733         if (ndr_flags & NDR_SCALARS) {
4734                 int level = ndr_push_get_switch_value(ndr, r);
4735                 switch (level) {
4736                         case 1: {
4737                                 NDR_CHECK(ndr_push_align(ndr, 4));
4738                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4739                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4740                         break; }
4741
4742                         case 2: {
4743                                 NDR_CHECK(ndr_push_align(ndr, 4));
4744                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4745                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4746                         break; }
4747
4748                         case 3: {
4749                                 NDR_CHECK(ndr_push_align(ndr, 4));
4750                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4751                                 NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4752                         break; }
4753
4754                         case 4: {
4755                                 NDR_CHECK(ndr_push_align(ndr, 4));
4756                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4757                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4758                         break; }
4759
4760                         default: {
4761                         break; }
4762
4763                 }
4764         }
4765         if (ndr_flags & NDR_BUFFERS) {
4766                 int level = ndr_push_get_switch_value(ndr, r);
4767                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4768                 switch (level) {
4769                         case 1:
4770                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4771                         break;
4772
4773                         case 2:
4774                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4775                         break;
4776
4777                         case 3:
4778                         break;
4779
4780                         case 4:
4781                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4782                         break;
4783
4784                         default:
4785                         break;
4786
4787                 }
4788         }
4789         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4790         return NDR_ERR_SUCCESS;
4791 }
4792
4793 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4794 {
4795         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4796         int level;
4797         level = ndr_pull_get_switch_value(ndr, r);
4798         if (ndr_flags & NDR_SCALARS) {
4799                 switch (level) {
4800                         case 1: {
4801                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4802                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4803                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4804                         break; }
4805
4806                         case 2: {
4807                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4808                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4809                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4810                         break; }
4811
4812                         case 3: {
4813                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4814                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4815                                 NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4816                         break; }
4817
4818                         case 4: {
4819                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4820                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4821                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4822                         break; }
4823
4824                         default: {
4825                         break; }
4826
4827                 }
4828         }
4829         if (ndr_flags & NDR_BUFFERS) {
4830                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
4831                 switch (level) {
4832                         case 1:
4833                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4834                         break;
4835
4836                         case 2:
4837                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4838                         break;
4839
4840                         case 3:
4841                         break;
4842
4843                         case 4:
4844                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4845                         break;
4846
4847                         default:
4848                         break;
4849
4850                 }
4851         }
4852         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
4853         return NDR_ERR_SUCCESS;
4854 }
4855
4856 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
4857 {
4858         int level;
4859         level = ndr_print_get_switch_value(ndr, r);
4860         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
4861         switch (level) {
4862                 case 1:
4863                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
4864                 break;
4865
4866                 case 2:
4867                         ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
4868                 break;
4869
4870                 case 3:
4871                         ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
4872                 break;
4873
4874                 case 4:
4875                         ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
4876                 break;
4877
4878                 default:
4879                 break;
4880
4881         }
4882 }
4883
4884 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
4885 {
4886         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
4887 }
4888
4889 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
4890 {
4891         if (ndr_flags & NDR_SCALARS) {
4892                 NDR_CHECK(ndr_push_align(ndr, 4));
4893                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4894                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4895                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4896                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4897                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4898                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4899                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4900                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4902                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4903                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4904                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4905                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4906         }
4907         if (ndr_flags & NDR_BUFFERS) {
4908                 if (r->printer_name) {
4909                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4910                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4911                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4912                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4913                 }
4914                 if (r->server_name) {
4915                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4916                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4917                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4918                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4919                 }
4920                 if (r->user_name) {
4921                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4922                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4923                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4924                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4925                 }
4926                 if (r->document_name) {
4927                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4928                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4929                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4930                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4931                 }
4932                 if (r->data_type) {
4933                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4934                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4935                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4936                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4937                 }
4938                 if (r->text_status) {
4939                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4940                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4941                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4942                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4943                 }
4944         }
4945         return NDR_ERR_SUCCESS;
4946 }
4947
4948 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
4949 {
4950         uint32_t _ptr_printer_name;
4951         TALLOC_CTX *_mem_save_printer_name_0;
4952         uint32_t _ptr_server_name;
4953         TALLOC_CTX *_mem_save_server_name_0;
4954         uint32_t _ptr_user_name;
4955         TALLOC_CTX *_mem_save_user_name_0;
4956         uint32_t _ptr_document_name;
4957         TALLOC_CTX *_mem_save_document_name_0;
4958         uint32_t _ptr_data_type;
4959         TALLOC_CTX *_mem_save_data_type_0;
4960         uint32_t _ptr_text_status;
4961         TALLOC_CTX *_mem_save_text_status_0;
4962         if (ndr_flags & NDR_SCALARS) {
4963                 NDR_CHECK(ndr_pull_align(ndr, 4));
4964                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4965                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4966                 if (_ptr_printer_name) {
4967                         NDR_PULL_ALLOC(ndr, r->printer_name);
4968                 } else {
4969                         r->printer_name = NULL;
4970                 }
4971                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4972                 if (_ptr_server_name) {
4973                         NDR_PULL_ALLOC(ndr, r->server_name);
4974                 } else {
4975                         r->server_name = NULL;
4976                 }
4977                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4978                 if (_ptr_user_name) {
4979                         NDR_PULL_ALLOC(ndr, r->user_name);
4980                 } else {
4981                         r->user_name = NULL;
4982                 }
4983                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4984                 if (_ptr_document_name) {
4985                         NDR_PULL_ALLOC(ndr, r->document_name);
4986                 } else {
4987                         r->document_name = NULL;
4988                 }
4989                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4990                 if (_ptr_data_type) {
4991                         NDR_PULL_ALLOC(ndr, r->data_type);
4992                 } else {
4993                         r->data_type = NULL;
4994                 }
4995                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4996                 if (_ptr_text_status) {
4997                         NDR_PULL_ALLOC(ndr, r->text_status);
4998                 } else {
4999                         r->text_status = NULL;
5000                 }
5001                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5003                 if (r->priority > 99) {
5004                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5005                 }
5006                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5007                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5008                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5009                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5010         }
5011         if (ndr_flags & NDR_BUFFERS) {
5012                 if (r->printer_name) {
5013                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5014                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5015                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5016                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5017                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5018                                 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));
5019                         }
5020                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5021                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5022                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5023                 }
5024                 if (r->server_name) {
5025                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5026                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5027                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5028                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5029                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5030                                 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));
5031                         }
5032                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5033                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5034                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5035                 }
5036                 if (r->user_name) {
5037                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5038                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5039                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5040                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5041                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5042                                 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));
5043                         }
5044                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5045                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5046                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5047                 }
5048                 if (r->document_name) {
5049                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5050                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5051                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5052                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5053                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5054                                 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));
5055                         }
5056                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5057                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5058                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5059                 }
5060                 if (r->data_type) {
5061                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5062                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5063                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5064                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5065                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5066                                 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));
5067                         }
5068                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5069                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5070                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5071                 }
5072                 if (r->text_status) {
5073                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5074                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5075                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5076                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5077                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5078                                 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));
5079                         }
5080                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5081                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5082                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5083                 }
5084         }
5085         return NDR_ERR_SUCCESS;
5086 }
5087
5088 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
5089 {
5090         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
5091         ndr->depth++;
5092         ndr_print_uint32(ndr, "job_id", r->job_id);
5093         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5094         ndr->depth++;
5095         if (r->printer_name) {
5096                 ndr_print_string(ndr, "printer_name", r->printer_name);
5097         }
5098         ndr->depth--;
5099         ndr_print_ptr(ndr, "server_name", r->server_name);
5100         ndr->depth++;
5101         if (r->server_name) {
5102                 ndr_print_string(ndr, "server_name", r->server_name);
5103         }
5104         ndr->depth--;
5105         ndr_print_ptr(ndr, "user_name", r->user_name);
5106         ndr->depth++;
5107         if (r->user_name) {
5108                 ndr_print_string(ndr, "user_name", r->user_name);
5109         }
5110         ndr->depth--;
5111         ndr_print_ptr(ndr, "document_name", r->document_name);
5112         ndr->depth++;
5113         if (r->document_name) {
5114                 ndr_print_string(ndr, "document_name", r->document_name);
5115         }
5116         ndr->depth--;
5117         ndr_print_ptr(ndr, "data_type", r->data_type);
5118         ndr->depth++;
5119         if (r->data_type) {
5120                 ndr_print_string(ndr, "data_type", r->data_type);
5121         }
5122         ndr->depth--;
5123         ndr_print_ptr(ndr, "text_status", r->text_status);
5124         ndr->depth++;
5125         if (r->text_status) {
5126                 ndr_print_string(ndr, "text_status", r->text_status);
5127         }
5128         ndr->depth--;
5129         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5130         ndr_print_uint32(ndr, "priority", r->priority);
5131         ndr_print_uint32(ndr, "position", r->position);
5132         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5133         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5134         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5135         ndr->depth--;
5136 }
5137
5138 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
5139 {
5140         if (ndr_flags & NDR_SCALARS) {
5141                 NDR_CHECK(ndr_push_align(ndr, 4));
5142                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5143                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5144                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5145                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5146                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5147                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5148                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5149                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5150                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5151                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5152                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5153                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5155                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5157                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5158                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5159                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5160                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5161                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5162                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5165         }
5166         if (ndr_flags & NDR_BUFFERS) {
5167                 if (r->printer_name) {
5168                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5169                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5170                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5171                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5172                 }
5173                 if (r->server_name) {
5174                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5175                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5176                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5177                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5178                 }
5179                 if (r->user_name) {
5180                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5181                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5182                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5183                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5184                 }
5185                 if (r->document_name) {
5186                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5187                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5188                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5189                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5190                 }
5191                 if (r->notify_name) {
5192                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5193                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5194                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5195                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5196                 }
5197                 if (r->data_type) {
5198                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5199                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5200                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5201                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5202                 }
5203                 if (r->print_processor) {
5204                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5205                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5206                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5207                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5208                 }
5209                 if (r->parameters) {
5210                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5211                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5212                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5213                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5214                 }
5215                 if (r->driver_name) {
5216                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5217                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5218                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5219                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5220                 }
5221                 if (r->text_status) {
5222                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5223                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5224                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5225                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5226                 }
5227         }
5228         return NDR_ERR_SUCCESS;
5229 }
5230
5231 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
5232 {
5233         uint32_t _ptr_printer_name;
5234         TALLOC_CTX *_mem_save_printer_name_0;
5235         uint32_t _ptr_server_name;
5236         TALLOC_CTX *_mem_save_server_name_0;
5237         uint32_t _ptr_user_name;
5238         TALLOC_CTX *_mem_save_user_name_0;
5239         uint32_t _ptr_document_name;
5240         TALLOC_CTX *_mem_save_document_name_0;
5241         uint32_t _ptr_notify_name;
5242         TALLOC_CTX *_mem_save_notify_name_0;
5243         uint32_t _ptr_data_type;
5244         TALLOC_CTX *_mem_save_data_type_0;
5245         uint32_t _ptr_print_processor;
5246         TALLOC_CTX *_mem_save_print_processor_0;
5247         uint32_t _ptr_parameters;
5248         TALLOC_CTX *_mem_save_parameters_0;
5249         uint32_t _ptr_driver_name;
5250         TALLOC_CTX *_mem_save_driver_name_0;
5251         uint32_t _ptr_text_status;
5252         TALLOC_CTX *_mem_save_text_status_0;
5253         if (ndr_flags & NDR_SCALARS) {
5254                 NDR_CHECK(ndr_pull_align(ndr, 4));
5255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5256                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5257                 if (_ptr_printer_name) {
5258                         NDR_PULL_ALLOC(ndr, r->printer_name);
5259                 } else {
5260                         r->printer_name = NULL;
5261                 }
5262                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5263                 if (_ptr_server_name) {
5264                         NDR_PULL_ALLOC(ndr, r->server_name);
5265                 } else {
5266                         r->server_name = NULL;
5267                 }
5268                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5269                 if (_ptr_user_name) {
5270                         NDR_PULL_ALLOC(ndr, r->user_name);
5271                 } else {
5272                         r->user_name = NULL;
5273                 }
5274                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5275                 if (_ptr_document_name) {
5276                         NDR_PULL_ALLOC(ndr, r->document_name);
5277                 } else {
5278                         r->document_name = NULL;
5279                 }
5280                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5281                 if (_ptr_notify_name) {
5282                         NDR_PULL_ALLOC(ndr, r->notify_name);
5283                 } else {
5284                         r->notify_name = NULL;
5285                 }
5286                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5287                 if (_ptr_data_type) {
5288                         NDR_PULL_ALLOC(ndr, r->data_type);
5289                 } else {
5290                         r->data_type = NULL;
5291                 }
5292                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5293                 if (_ptr_print_processor) {
5294                         NDR_PULL_ALLOC(ndr, r->print_processor);
5295                 } else {
5296                         r->print_processor = NULL;
5297                 }
5298                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5299                 if (_ptr_parameters) {
5300                         NDR_PULL_ALLOC(ndr, r->parameters);
5301                 } else {
5302                         r->parameters = NULL;
5303                 }
5304                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5305                 if (_ptr_driver_name) {
5306                         NDR_PULL_ALLOC(ndr, r->driver_name);
5307                 } else {
5308                         r->driver_name = NULL;
5309                 }
5310                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5311                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5312                 if (_ptr_text_status) {
5313                         NDR_PULL_ALLOC(ndr, r->text_status);
5314                 } else {
5315                         r->text_status = NULL;
5316                 }
5317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5318                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5319                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5320                 if (r->priority > 99) {
5321                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5322                 }
5323                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5324                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5328                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5331         }
5332         if (ndr_flags & NDR_BUFFERS) {
5333                 if (r->printer_name) {
5334                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5335                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5336                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5337                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5338                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5339                                 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));
5340                         }
5341                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5342                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5343                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5344                 }
5345                 if (r->server_name) {
5346                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5347                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5348                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5349                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5350                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5351                                 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));
5352                         }
5353                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5354                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5355                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5356                 }
5357                 if (r->user_name) {
5358                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5359                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5360                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5361                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5362                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5363                                 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));
5364                         }
5365                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5366                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5367                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5368                 }
5369                 if (r->document_name) {
5370                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5371                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5372                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5373                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5374                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5375                                 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));
5376                         }
5377                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5378                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5379                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5380                 }
5381                 if (r->notify_name) {
5382                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5383                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5384                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5385                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5386                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5387                                 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));
5388                         }
5389                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5390                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5391                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5392                 }
5393                 if (r->data_type) {
5394                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5395                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5396                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5397                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5398                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5399                                 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));
5400                         }
5401                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5402                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5403                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5404                 }
5405                 if (r->print_processor) {
5406                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5407                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5408                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5409                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5410                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5411                                 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));
5412                         }
5413                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5414                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5415                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5416                 }
5417                 if (r->parameters) {
5418                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5419                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5420                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5421                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5422                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5423                                 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));
5424                         }
5425                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5426                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5427                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5428                 }
5429                 if (r->driver_name) {
5430                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5431                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5432                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5433                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5434                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5435                                 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));
5436                         }
5437                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5438                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5439                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5440                 }
5441                 if (r->text_status) {
5442                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5443                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5444                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5445                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5446                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5447                                 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));
5448                         }
5449                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5450                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5451                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5452                 }
5453         }
5454         return NDR_ERR_SUCCESS;
5455 }
5456
5457 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
5458 {
5459         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
5460         ndr->depth++;
5461         ndr_print_uint32(ndr, "job_id", r->job_id);
5462         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5463         ndr->depth++;
5464         if (r->printer_name) {
5465                 ndr_print_string(ndr, "printer_name", r->printer_name);
5466         }
5467         ndr->depth--;
5468         ndr_print_ptr(ndr, "server_name", r->server_name);
5469         ndr->depth++;
5470         if (r->server_name) {
5471                 ndr_print_string(ndr, "server_name", r->server_name);
5472         }
5473         ndr->depth--;
5474         ndr_print_ptr(ndr, "user_name", r->user_name);
5475         ndr->depth++;
5476         if (r->user_name) {
5477                 ndr_print_string(ndr, "user_name", r->user_name);
5478         }
5479         ndr->depth--;
5480         ndr_print_ptr(ndr, "document_name", r->document_name);
5481         ndr->depth++;
5482         if (r->document_name) {
5483                 ndr_print_string(ndr, "document_name", r->document_name);
5484         }
5485         ndr->depth--;
5486         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5487         ndr->depth++;
5488         if (r->notify_name) {
5489                 ndr_print_string(ndr, "notify_name", r->notify_name);
5490         }
5491         ndr->depth--;
5492         ndr_print_ptr(ndr, "data_type", r->data_type);
5493         ndr->depth++;
5494         if (r->data_type) {
5495                 ndr_print_string(ndr, "data_type", r->data_type);
5496         }
5497         ndr->depth--;
5498         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5499         ndr->depth++;
5500         if (r->print_processor) {
5501                 ndr_print_string(ndr, "print_processor", r->print_processor);
5502         }
5503         ndr->depth--;
5504         ndr_print_ptr(ndr, "parameters", r->parameters);
5505         ndr->depth++;
5506         if (r->parameters) {
5507                 ndr_print_string(ndr, "parameters", r->parameters);
5508         }
5509         ndr->depth--;
5510         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5511         ndr->depth++;
5512         if (r->driver_name) {
5513                 ndr_print_string(ndr, "driver_name", r->driver_name);
5514         }
5515         ndr->depth--;
5516         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5517         ndr_print_ptr(ndr, "text_status", r->text_status);
5518         ndr->depth++;
5519         if (r->text_status) {
5520                 ndr_print_string(ndr, "text_status", r->text_status);
5521         }
5522         ndr->depth--;
5523         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5524         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5525         ndr_print_uint32(ndr, "priority", r->priority);
5526         ndr_print_uint32(ndr, "position", r->position);
5527         ndr_print_uint32(ndr, "start_time", r->start_time);
5528         ndr_print_uint32(ndr, "until_time", r->until_time);
5529         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5530         ndr_print_uint32(ndr, "size", r->size);
5531         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5532         ndr_print_uint32(ndr, "time", r->time);
5533         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5534         ndr->depth--;
5535 }
5536
5537 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
5538 {
5539         if (ndr_flags & NDR_SCALARS) {
5540                 NDR_CHECK(ndr_push_align(ndr, 4));
5541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5542                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5543                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5544                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5545                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5546                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5547                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5548                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5549                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5550                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5551                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5552                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5553                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5554                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5555                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5559                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5560                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5561                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5562                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5565         }
5566         if (ndr_flags & NDR_BUFFERS) {
5567                 if (r->printer_name) {
5568                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5569                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5570                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5571                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5572                 }
5573                 if (r->server_name) {
5574                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5575                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5576                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5577                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5578                 }
5579                 if (r->user_name) {
5580                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5581                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5582                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5583                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5584                 }
5585                 if (r->document_name) {
5586                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5587                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5588                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5589                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5590                 }
5591                 if (r->notify_name) {
5592                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5593                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5594                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5595                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5596                 }
5597                 if (r->data_type) {
5598                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5599                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5600                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5601                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5602                 }
5603                 if (r->print_processor) {
5604                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5605                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5606                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5607                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5608                 }
5609                 if (r->parameters) {
5610                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5611                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5612                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5613                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5614                 }
5615                 if (r->driver_name) {
5616                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5617                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5618                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5619                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5620                 }
5621                 if (r->text_status) {
5622                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5623                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5624                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5625                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5626                 }
5627         }
5628         return NDR_ERR_SUCCESS;
5629 }
5630
5631 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5632 {
5633         uint32_t _ptr_printer_name;
5634         TALLOC_CTX *_mem_save_printer_name_0;
5635         uint32_t _ptr_server_name;
5636         TALLOC_CTX *_mem_save_server_name_0;
5637         uint32_t _ptr_user_name;
5638         TALLOC_CTX *_mem_save_user_name_0;
5639         uint32_t _ptr_document_name;
5640         TALLOC_CTX *_mem_save_document_name_0;
5641         uint32_t _ptr_notify_name;
5642         TALLOC_CTX *_mem_save_notify_name_0;
5643         uint32_t _ptr_data_type;
5644         TALLOC_CTX *_mem_save_data_type_0;
5645         uint32_t _ptr_print_processor;
5646         TALLOC_CTX *_mem_save_print_processor_0;
5647         uint32_t _ptr_parameters;
5648         TALLOC_CTX *_mem_save_parameters_0;
5649         uint32_t _ptr_driver_name;
5650         TALLOC_CTX *_mem_save_driver_name_0;
5651         uint32_t _ptr_text_status;
5652         TALLOC_CTX *_mem_save_text_status_0;
5653         if (ndr_flags & NDR_SCALARS) {
5654                 NDR_CHECK(ndr_pull_align(ndr, 4));
5655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5656                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5657                 if (_ptr_printer_name) {
5658                         NDR_PULL_ALLOC(ndr, r->printer_name);
5659                 } else {
5660                         r->printer_name = NULL;
5661                 }
5662                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5663                 if (_ptr_server_name) {
5664                         NDR_PULL_ALLOC(ndr, r->server_name);
5665                 } else {
5666                         r->server_name = NULL;
5667                 }
5668                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5669                 if (_ptr_user_name) {
5670                         NDR_PULL_ALLOC(ndr, r->user_name);
5671                 } else {
5672                         r->user_name = NULL;
5673                 }
5674                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5675                 if (_ptr_document_name) {
5676                         NDR_PULL_ALLOC(ndr, r->document_name);
5677                 } else {
5678                         r->document_name = NULL;
5679                 }
5680                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5681                 if (_ptr_notify_name) {
5682                         NDR_PULL_ALLOC(ndr, r->notify_name);
5683                 } else {
5684                         r->notify_name = NULL;
5685                 }
5686                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5687                 if (_ptr_data_type) {
5688                         NDR_PULL_ALLOC(ndr, r->data_type);
5689                 } else {
5690                         r->data_type = NULL;
5691                 }
5692                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5693                 if (_ptr_print_processor) {
5694                         NDR_PULL_ALLOC(ndr, r->print_processor);
5695                 } else {
5696                         r->print_processor = NULL;
5697                 }
5698                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5699                 if (_ptr_parameters) {
5700                         NDR_PULL_ALLOC(ndr, r->parameters);
5701                 } else {
5702                         r->parameters = NULL;
5703                 }
5704                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5705                 if (_ptr_driver_name) {
5706                         NDR_PULL_ALLOC(ndr, r->driver_name);
5707                 } else {
5708                         r->driver_name = NULL;
5709                 }
5710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5711                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5712                 if (_ptr_text_status) {
5713                         NDR_PULL_ALLOC(ndr, r->text_status);
5714                 } else {
5715                         r->text_status = NULL;
5716                 }
5717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5718                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5720                 if (r->priority > 99) {
5721                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5722                 }
5723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5724                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5725                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5727                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5728                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5729                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5731                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5732         }
5733         if (ndr_flags & NDR_BUFFERS) {
5734                 if (r->printer_name) {
5735                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5736                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5737                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5738                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5739                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5740                                 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));
5741                         }
5742                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5743                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5744                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5745                 }
5746                 if (r->server_name) {
5747                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5748                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5749                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5750                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5751                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5752                                 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));
5753                         }
5754                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5755                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5756                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5757                 }
5758                 if (r->user_name) {
5759                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5760                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5761                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5762                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5763                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5764                                 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));
5765                         }
5766                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5767                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5768                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5769                 }
5770                 if (r->document_name) {
5771                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5772                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5773                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5774                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5775                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5776                                 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));
5777                         }
5778                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5779                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5780                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5781                 }
5782                 if (r->notify_name) {
5783                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5784                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5785                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5786                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5787                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5788                                 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));
5789                         }
5790                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5791                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5792                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5793                 }
5794                 if (r->data_type) {
5795                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5796                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5797                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5798                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5799                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5800                                 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));
5801                         }
5802                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5803                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5804                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5805                 }
5806                 if (r->print_processor) {
5807                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5808                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5809                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5810                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5811                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5812                                 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));
5813                         }
5814                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5815                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5816                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5817                 }
5818                 if (r->parameters) {
5819                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5820                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5821                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5822                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5823                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5824                                 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));
5825                         }
5826                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5827                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5828                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5829                 }
5830                 if (r->driver_name) {
5831                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5832                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5833                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5834                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5835                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5836                                 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));
5837                         }
5838                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5839                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5840                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5841                 }
5842                 if (r->text_status) {
5843                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5844                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5845                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5846                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5847                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5848                                 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));
5849                         }
5850                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5851                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5852                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5853                 }
5854         }
5855         return NDR_ERR_SUCCESS;
5856 }
5857
5858 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
5859 {
5860         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
5861         ndr->depth++;
5862         ndr_print_uint32(ndr, "job_id", r->job_id);
5863         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5864         ndr->depth++;
5865         if (r->printer_name) {
5866                 ndr_print_string(ndr, "printer_name", r->printer_name);
5867         }
5868         ndr->depth--;
5869         ndr_print_ptr(ndr, "server_name", r->server_name);
5870         ndr->depth++;
5871         if (r->server_name) {
5872                 ndr_print_string(ndr, "server_name", r->server_name);
5873         }
5874         ndr->depth--;
5875         ndr_print_ptr(ndr, "user_name", r->user_name);
5876         ndr->depth++;
5877         if (r->user_name) {
5878                 ndr_print_string(ndr, "user_name", r->user_name);
5879         }
5880         ndr->depth--;
5881         ndr_print_ptr(ndr, "document_name", r->document_name);
5882         ndr->depth++;
5883         if (r->document_name) {
5884                 ndr_print_string(ndr, "document_name", r->document_name);
5885         }
5886         ndr->depth--;
5887         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5888         ndr->depth++;
5889         if (r->notify_name) {
5890                 ndr_print_string(ndr, "notify_name", r->notify_name);
5891         }
5892         ndr->depth--;
5893         ndr_print_ptr(ndr, "data_type", r->data_type);
5894         ndr->depth++;
5895         if (r->data_type) {
5896                 ndr_print_string(ndr, "data_type", r->data_type);
5897         }
5898         ndr->depth--;
5899         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5900         ndr->depth++;
5901         if (r->print_processor) {
5902                 ndr_print_string(ndr, "print_processor", r->print_processor);
5903         }
5904         ndr->depth--;
5905         ndr_print_ptr(ndr, "parameters", r->parameters);
5906         ndr->depth++;
5907         if (r->parameters) {
5908                 ndr_print_string(ndr, "parameters", r->parameters);
5909         }
5910         ndr->depth--;
5911         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5912         ndr->depth++;
5913         if (r->driver_name) {
5914                 ndr_print_string(ndr, "driver_name", r->driver_name);
5915         }
5916         ndr->depth--;
5917         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5918         ndr_print_ptr(ndr, "text_status", r->text_status);
5919         ndr->depth++;
5920         if (r->text_status) {
5921                 ndr_print_string(ndr, "text_status", r->text_status);
5922         }
5923         ndr->depth--;
5924         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5925         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5926         ndr_print_uint32(ndr, "priority", r->priority);
5927         ndr_print_uint32(ndr, "position", r->position);
5928         ndr_print_uint32(ndr, "start_time", r->start_time);
5929         ndr_print_uint32(ndr, "until_time", r->until_time);
5930         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5931         ndr_print_uint32(ndr, "size", r->size);
5932         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5933         ndr_print_uint32(ndr, "time", r->time);
5934         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5935         ndr_print_uint32(ndr, "size_high", r->size_high);
5936         ndr->depth--;
5937 }
5938
5939 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
5940 {
5941         if (ndr_flags & NDR_SCALARS) {
5942                 int level = ndr_push_get_switch_value(ndr, r);
5943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5944                 switch (level) {
5945                         case 1: {
5946                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
5947                         break; }
5948
5949                         case 2: {
5950                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
5951                         break; }
5952
5953                         case 3: {
5954                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
5955                         break; }
5956
5957                         case 4: {
5958                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
5959                         break; }
5960
5961                         default: {
5962                         break; }
5963
5964                 }
5965         }
5966         if (ndr_flags & NDR_BUFFERS) {
5967                 int level = ndr_push_get_switch_value(ndr, r);
5968                 switch (level) {
5969                         case 1:
5970                                 if (r->info1) {
5971                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5972                                 }
5973                         break;
5974
5975                         case 2:
5976                                 if (r->info2) {
5977                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5978                                 }
5979                         break;
5980
5981                         case 3:
5982                                 if (r->info3) {
5983                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5984                                 }
5985                         break;
5986
5987                         case 4:
5988                                 if (r->info4) {
5989                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5990                                 }
5991                         break;
5992
5993                         default:
5994                         break;
5995
5996                 }
5997         }
5998         return NDR_ERR_SUCCESS;
5999 }
6000
6001 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
6002 {
6003         int level;
6004         uint32_t _level;
6005         TALLOC_CTX *_mem_save_info1_0;
6006         TALLOC_CTX *_mem_save_info2_0;
6007         TALLOC_CTX *_mem_save_info3_0;
6008         TALLOC_CTX *_mem_save_info4_0;
6009         level = ndr_pull_get_switch_value(ndr, r);
6010         if (ndr_flags & NDR_SCALARS) {
6011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6012                 if (_level != level) {
6013                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
6014                 }
6015                 switch (level) {
6016                         case 1: {
6017                                 uint32_t _ptr_info1;
6018                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6019                                 if (_ptr_info1) {
6020                                         NDR_PULL_ALLOC(ndr, r->info1);
6021                                 } else {
6022                                         r->info1 = NULL;
6023                                 }
6024                         break; }
6025
6026                         case 2: {
6027                                 uint32_t _ptr_info2;
6028                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6029                                 if (_ptr_info2) {
6030                                         NDR_PULL_ALLOC(ndr, r->info2);
6031                                 } else {
6032                                         r->info2 = NULL;
6033                                 }
6034                         break; }
6035
6036                         case 3: {
6037                                 uint32_t _ptr_info3;
6038                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6039                                 if (_ptr_info3) {
6040                                         NDR_PULL_ALLOC(ndr, r->info3);
6041                                 } else {
6042                                         r->info3 = NULL;
6043                                 }
6044                         break; }
6045
6046                         case 4: {
6047                                 uint32_t _ptr_info4;
6048                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6049                                 if (_ptr_info4) {
6050                                         NDR_PULL_ALLOC(ndr, r->info4);
6051                                 } else {
6052                                         r->info4 = NULL;
6053                                 }
6054                         break; }
6055
6056                         default: {
6057                         break; }
6058
6059                 }
6060         }
6061         if (ndr_flags & NDR_BUFFERS) {
6062                 switch (level) {
6063                         case 1:
6064                                 if (r->info1) {
6065                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6066                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6067                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6068                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6069                                 }
6070                         break;
6071
6072                         case 2:
6073                                 if (r->info2) {
6074                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6075                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
6076                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6077                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
6078                                 }
6079                         break;
6080
6081                         case 3:
6082                                 if (r->info3) {
6083                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
6084                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
6085                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6086                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
6087                                 }
6088                         break;
6089
6090                         case 4:
6091                                 if (r->info4) {
6092                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
6093                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
6094                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6095                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
6096                                 }
6097                         break;
6098
6099                         default:
6100                         break;
6101
6102                 }
6103         }
6104         return NDR_ERR_SUCCESS;
6105 }
6106
6107 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
6108 {
6109         int level;
6110         level = ndr_print_get_switch_value(ndr, r);
6111         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
6112         switch (level) {
6113                 case 1:
6114                         ndr_print_ptr(ndr, "info1", r->info1);
6115                         ndr->depth++;
6116                         if (r->info1) {
6117                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
6118                         }
6119                         ndr->depth--;
6120                 break;
6121
6122                 case 2:
6123                         ndr_print_ptr(ndr, "info2", r->info2);
6124                         ndr->depth++;
6125                         if (r->info2) {
6126                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
6127                         }
6128                         ndr->depth--;
6129                 break;
6130
6131                 case 3:
6132                         ndr_print_ptr(ndr, "info3", r->info3);
6133                         ndr->depth++;
6134                         if (r->info3) {
6135                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
6136                         }
6137                         ndr->depth--;
6138                 break;
6139
6140                 case 4:
6141                         ndr_print_ptr(ndr, "info4", r->info4);
6142                         ndr->depth++;
6143                         if (r->info4) {
6144                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
6145                         }
6146                         ndr->depth--;
6147                 break;
6148
6149                 default:
6150                 break;
6151
6152         }
6153 }
6154
6155 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
6156 {
6157         if (ndr_flags & NDR_SCALARS) {
6158                 NDR_CHECK(ndr_push_align(ndr, 4));
6159                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
6160                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
6161                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6162         }
6163         if (ndr_flags & NDR_BUFFERS) {
6164                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6165         }
6166         return NDR_ERR_SUCCESS;
6167 }
6168
6169 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
6170 {
6171         if (ndr_flags & NDR_SCALARS) {
6172                 NDR_CHECK(ndr_pull_align(ndr, 4));
6173                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
6174                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
6175                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6176         }
6177         if (ndr_flags & NDR_BUFFERS) {
6178                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6179         }
6180         return NDR_ERR_SUCCESS;
6181 }
6182
6183 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
6184 {
6185         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
6186         ndr->depth++;
6187         ndr_print_uint32(ndr, "level", r->level);
6188         ndr_print_set_switch_value(ndr, &r->info, r->level);
6189         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
6190         ndr->depth--;
6191 }
6192
6193 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
6194 {
6195         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
6196         return NDR_ERR_SUCCESS;
6197 }
6198
6199 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
6200 {
6201         uint32_t v;
6202         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
6203         *r = v;
6204         return NDR_ERR_SUCCESS;
6205 }
6206
6207 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
6208 {
6209         const char *val = NULL;
6210
6211         switch (r) {
6212                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
6213                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
6214                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
6215                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
6216                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
6217                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
6218                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
6219                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
6220                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
6221         }
6222         ndr_print_enum(ndr, name, "ENUM", val, r);
6223 }
6224
6225 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
6226 {
6227         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
6228         return NDR_ERR_SUCCESS;
6229 }
6230
6231 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
6232 {
6233         uint32_t v;
6234         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
6235         *r = v;
6236         return NDR_ERR_SUCCESS;
6237 }
6238
6239 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
6240 {
6241         const char *val = NULL;
6242
6243         switch (r) {
6244                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
6245                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
6246                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
6247                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
6248                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
6249         }
6250         ndr_print_enum(ndr, name, "ENUM", val, r);
6251 }
6252
6253 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
6254 {
6255         if (ndr_flags & NDR_SCALARS) {
6256                 NDR_CHECK(ndr_push_align(ndr, 4));
6257                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6258                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
6261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
6262                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
6264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
6265                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
6266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
6267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
6268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
6269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
6270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
6271                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
6272                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
6273                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
6274                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
6275                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
6276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
6277                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
6278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
6279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
6280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
6281                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
6282                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
6283                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
6284                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
6285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
6286         }
6287         if (ndr_flags & NDR_BUFFERS) {
6288                 if (r->servername) {
6289                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6290                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6291                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6292                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6293                 }
6294                 if (r->printername) {
6295                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6296                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6297                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6298                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6299                 }
6300         }
6301         return NDR_ERR_SUCCESS;
6302 }
6303
6304 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
6305 {
6306         uint32_t _ptr_servername;
6307         TALLOC_CTX *_mem_save_servername_0;
6308         uint32_t _ptr_printername;
6309         TALLOC_CTX *_mem_save_printername_0;
6310         if (ndr_flags & NDR_SCALARS) {
6311                 NDR_CHECK(ndr_pull_align(ndr, 4));
6312                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6313                 if (_ptr_servername) {
6314                         NDR_PULL_ALLOC(ndr, r->servername);
6315                 } else {
6316                         r->servername = NULL;
6317                 }
6318                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6319                 if (_ptr_printername) {
6320                         NDR_PULL_ALLOC(ndr, r->printername);
6321                 } else {
6322                         r->printername = NULL;
6323                 }
6324                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
6326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
6327                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6328                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
6329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
6330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
6331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
6332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
6333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
6334                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
6335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
6336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
6337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
6338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
6339                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
6340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
6341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
6342                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
6343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
6344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
6345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
6346                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
6347                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
6348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
6349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
6350                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
6351         }
6352         if (ndr_flags & NDR_BUFFERS) {
6353                 if (r->servername) {
6354                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6355                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6356                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6357                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6358                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6359                                 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));
6360                         }
6361                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6362                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6363                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6364                 }
6365                 if (r->printername) {
6366                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6367                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6368                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6369                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6370                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6371                                 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));
6372                         }
6373                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6374                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6375                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6376                 }
6377         }
6378         return NDR_ERR_SUCCESS;
6379 }
6380
6381 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
6382 {
6383         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
6384         ndr->depth++;
6385         ndr_print_ptr(ndr, "servername", r->servername);
6386         ndr->depth++;
6387         if (r->servername) {
6388                 ndr_print_string(ndr, "servername", r->servername);
6389         }
6390         ndr->depth--;
6391         ndr_print_ptr(ndr, "printername", r->printername);
6392         ndr->depth++;
6393         if (r->printername) {
6394                 ndr_print_string(ndr, "printername", r->printername);
6395         }
6396         ndr->depth--;
6397         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6398         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
6399         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
6400         ndr_print_spoolss_Time(ndr, "time", &r->time);
6401         ndr_print_uint32(ndr, "global_counter", r->global_counter);
6402         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6403         ndr_print_uint32(ndr, "version", r->version);
6404         ndr_print_uint32(ndr, "free_build", r->free_build);
6405         ndr_print_uint32(ndr, "spooling", r->spooling);
6406         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
6407         ndr_print_uint32(ndr, "session_counter", r->session_counter);
6408         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
6409         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
6410         ndr_print_uint32(ndr, "job_error", r->job_error);
6411         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
6412         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
6413         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
6414         ndr_print_uint32(ndr, "change_id", r->change_id);
6415         ndr_print_WERROR(ndr, "last_error", r->last_error);
6416         ndr_print_uint32(ndr, "status", r->status);
6417         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
6418         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
6419         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
6420         ndr_print_uint16(ndr, "processor_level", r->processor_level);
6421         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
6422         ndr_print_uint32(ndr, "reserved2", r->reserved2);
6423         ndr_print_uint32(ndr, "reserved3", r->reserved3);
6424         ndr->depth--;
6425 }
6426
6427 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
6428 {
6429         if (ndr_flags & NDR_SCALARS) {
6430                 NDR_CHECK(ndr_push_align(ndr, 4));
6431                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
6432                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
6433                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
6434                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6435         }
6436         if (ndr_flags & NDR_BUFFERS) {
6437                 if (r->description) {
6438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, 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->description, CH_UTF16)));
6441                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6442                 }
6443                 if (r->name) {
6444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6445                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6446                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6447                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6448                 }
6449                 if (r->comment) {
6450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6451                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6452                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6453                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6454                 }
6455         }
6456         return NDR_ERR_SUCCESS;
6457 }
6458
6459 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
6460 {
6461         uint32_t _ptr_description;
6462         TALLOC_CTX *_mem_save_description_0;
6463         uint32_t _ptr_name;
6464         TALLOC_CTX *_mem_save_name_0;
6465         uint32_t _ptr_comment;
6466         TALLOC_CTX *_mem_save_comment_0;
6467         if (ndr_flags & NDR_SCALARS) {
6468                 NDR_CHECK(ndr_pull_align(ndr, 4));
6469                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
6470                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
6471                 if (_ptr_description) {
6472                         NDR_PULL_ALLOC(ndr, r->description);
6473                 } else {
6474                         r->description = NULL;
6475                 }
6476                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
6477                 if (_ptr_name) {
6478                         NDR_PULL_ALLOC(ndr, r->name);
6479                 } else {
6480                         r->name = NULL;
6481                 }
6482                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6483                 if (_ptr_comment) {
6484                         NDR_PULL_ALLOC(ndr, r->comment);
6485                 } else {
6486                         r->comment = NULL;
6487                 }
6488         }
6489         if (ndr_flags & NDR_BUFFERS) {
6490                 if (r->description) {
6491                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
6492                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
6493                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
6494                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
6495                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
6496                                 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));
6497                         }
6498                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
6499                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
6500                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
6501                 }
6502                 if (r->name) {
6503                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6504                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
6505                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
6506                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
6507                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
6508                                 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));
6509                         }
6510                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
6511                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
6512                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6513                 }
6514                 if (r->comment) {
6515                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6516                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6517                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6518                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6519                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6520                                 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));
6521                         }
6522                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6523                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6524                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6525                 }
6526         }
6527         return NDR_ERR_SUCCESS;
6528 }
6529
6530 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
6531 {
6532         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
6533         ndr->depth++;
6534         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
6535         ndr_print_ptr(ndr, "description", r->description);
6536         ndr->depth++;
6537         if (r->description) {
6538                 ndr_print_string(ndr, "description", r->description);
6539         }
6540         ndr->depth--;
6541         ndr_print_ptr(ndr, "name", r->name);
6542         ndr->depth++;
6543         if (r->name) {
6544                 ndr_print_string(ndr, "name", r->name);
6545         }
6546         ndr->depth--;
6547         ndr_print_ptr(ndr, "comment", r->comment);
6548         ndr->depth++;
6549         if (r->comment) {
6550                 ndr_print_string(ndr, "comment", r->comment);
6551         }
6552         ndr->depth--;
6553         ndr->depth--;
6554 }
6555
6556 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
6557 {
6558         if (ndr_flags & NDR_SCALARS) {
6559                 NDR_CHECK(ndr_push_align(ndr, 4));
6560                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6561                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6562                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6563                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6564                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6565                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6566                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6567                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
6568                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6569                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6570                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6571                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6572                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
6573                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6574                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6575                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6576                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6577                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6578                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6579                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6580                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6581         }
6582         if (ndr_flags & NDR_BUFFERS) {
6583                 if (r->servername) {
6584                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6585                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6586                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6587                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6588                 }
6589                 if (r->printername) {
6590                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6591                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6592                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6593                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6594                 }
6595                 if (r->sharename) {
6596                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6597                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6598                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6599                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6600                 }
6601                 if (r->portname) {
6602                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6603                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6604                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6605                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6606                 }
6607                 if (r->drivername) {
6608                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6609                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6610                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6611                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6612                 }
6613                 if (r->comment) {
6614                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6615                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6616                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6617                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6618                 }
6619                 if (r->location) {
6620                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6621                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6622                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6623                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6624                 }
6625                 if (r->devmode) {
6626                         {
6627                                 struct ndr_push *_ndr_devmode;
6628                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6629                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6630                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
6631                         }
6632                 }
6633                 if (r->sepfile) {
6634                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6635                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6636                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6637                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6638                 }
6639                 if (r->printprocessor) {
6640                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6641                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6642                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6643                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6644                 }
6645                 if (r->datatype) {
6646                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6647                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6648                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6649                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6650                 }
6651                 if (r->parameters) {
6652                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6653                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6654                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6655                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6656                 }
6657                 if (r->secdesc) {
6658                         {
6659                                 struct ndr_push *_ndr_secdesc;
6660                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6661                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6662                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6663                         }
6664                 }
6665         }
6666         return NDR_ERR_SUCCESS;
6667 }
6668
6669 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6670 {
6671         uint32_t _ptr_servername;
6672         TALLOC_CTX *_mem_save_servername_0;
6673         uint32_t _ptr_printername;
6674         TALLOC_CTX *_mem_save_printername_0;
6675         uint32_t _ptr_sharename;
6676         TALLOC_CTX *_mem_save_sharename_0;
6677         uint32_t _ptr_portname;
6678         TALLOC_CTX *_mem_save_portname_0;
6679         uint32_t _ptr_drivername;
6680         TALLOC_CTX *_mem_save_drivername_0;
6681         uint32_t _ptr_comment;
6682         TALLOC_CTX *_mem_save_comment_0;
6683         uint32_t _ptr_location;
6684         TALLOC_CTX *_mem_save_location_0;
6685         uint32_t _ptr_devmode;
6686         TALLOC_CTX *_mem_save_devmode_0;
6687         uint32_t _ptr_sepfile;
6688         TALLOC_CTX *_mem_save_sepfile_0;
6689         uint32_t _ptr_printprocessor;
6690         TALLOC_CTX *_mem_save_printprocessor_0;
6691         uint32_t _ptr_datatype;
6692         TALLOC_CTX *_mem_save_datatype_0;
6693         uint32_t _ptr_parameters;
6694         TALLOC_CTX *_mem_save_parameters_0;
6695         uint32_t _ptr_secdesc;
6696         TALLOC_CTX *_mem_save_secdesc_0;
6697         if (ndr_flags & NDR_SCALARS) {
6698                 NDR_CHECK(ndr_pull_align(ndr, 4));
6699                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6700                 if (_ptr_servername) {
6701                         NDR_PULL_ALLOC(ndr, r->servername);
6702                 } else {
6703                         r->servername = NULL;
6704                 }
6705                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6706                 if (_ptr_printername) {
6707                         NDR_PULL_ALLOC(ndr, r->printername);
6708                 } else {
6709                         r->printername = NULL;
6710                 }
6711                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6712                 if (_ptr_sharename) {
6713                         NDR_PULL_ALLOC(ndr, r->sharename);
6714                 } else {
6715                         r->sharename = NULL;
6716                 }
6717                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6718                 if (_ptr_portname) {
6719                         NDR_PULL_ALLOC(ndr, r->portname);
6720                 } else {
6721                         r->portname = NULL;
6722                 }
6723                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6724                 if (_ptr_drivername) {
6725                         NDR_PULL_ALLOC(ndr, r->drivername);
6726                 } else {
6727                         r->drivername = NULL;
6728                 }
6729                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6730                 if (_ptr_comment) {
6731                         NDR_PULL_ALLOC(ndr, r->comment);
6732                 } else {
6733                         r->comment = NULL;
6734                 }
6735                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6736                 if (_ptr_location) {
6737                         NDR_PULL_ALLOC(ndr, r->location);
6738                 } else {
6739                         r->location = NULL;
6740                 }
6741                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
6742                 if (_ptr_devmode) {
6743                         NDR_PULL_ALLOC(ndr, r->devmode);
6744                 } else {
6745                         r->devmode = NULL;
6746                 }
6747                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6748                 if (_ptr_sepfile) {
6749                         NDR_PULL_ALLOC(ndr, r->sepfile);
6750                 } else {
6751                         r->sepfile = NULL;
6752                 }
6753                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6754                 if (_ptr_printprocessor) {
6755                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6756                 } else {
6757                         r->printprocessor = NULL;
6758                 }
6759                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6760                 if (_ptr_datatype) {
6761                         NDR_PULL_ALLOC(ndr, r->datatype);
6762                 } else {
6763                         r->datatype = NULL;
6764                 }
6765                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6766                 if (_ptr_parameters) {
6767                         NDR_PULL_ALLOC(ndr, r->parameters);
6768                 } else {
6769                         r->parameters = NULL;
6770                 }
6771                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
6772                 if (_ptr_secdesc) {
6773                         NDR_PULL_ALLOC(ndr, r->secdesc);
6774                 } else {
6775                         r->secdesc = NULL;
6776                 }
6777                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6778                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6779                 if (r->priority > 99) {
6780                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6781                 }
6782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
6783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
6784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
6785                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6786                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6787                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
6788         }
6789         if (ndr_flags & NDR_BUFFERS) {
6790                 if (r->servername) {
6791                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6792                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6793                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6794                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6795                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6796                                 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));
6797                         }
6798                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6799                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6800                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6801                 }
6802                 if (r->printername) {
6803                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6804                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6805                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6806                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6807                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6808                                 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));
6809                         }
6810                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6811                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6812                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6813                 }
6814                 if (r->sharename) {
6815                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
6816                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
6817                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
6818                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
6819                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
6820                                 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));
6821                         }
6822                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
6823                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
6824                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
6825                 }
6826                 if (r->portname) {
6827                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6828                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6829                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6830                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6831                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6832                                 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));
6833                         }
6834                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6835                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6836                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6837                 }
6838                 if (r->drivername) {
6839                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6840                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
6841                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
6842                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
6843                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
6844                                 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));
6845                         }
6846                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
6847                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
6848                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
6849                 }
6850                 if (r->comment) {
6851                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6852                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6853                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6854                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6855                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6856                                 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));
6857                         }
6858                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6859                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6860                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6861                 }
6862                 if (r->location) {
6863                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
6864                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
6865                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
6866                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
6867                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
6868                                 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));
6869                         }
6870                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
6871                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
6872                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
6873                 }
6874                 if (r->devmode) {
6875                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
6876                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
6877                         {
6878                                 struct ndr_pull *_ndr_devmode;
6879                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6880                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6881                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
6882                         }
6883                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
6884                 }
6885                 if (r->sepfile) {
6886                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
6887                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
6888                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
6889                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
6890                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
6891                                 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));
6892                         }
6893                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
6894                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
6895                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
6896                 }
6897                 if (r->printprocessor) {
6898                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6899                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
6900                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
6901                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
6902                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
6903                                 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));
6904                         }
6905                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
6906                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
6907                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
6908                 }
6909                 if (r->datatype) {
6910                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6911                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
6912                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
6913                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
6914                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
6915                                 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));
6916                         }
6917                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
6918                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
6919                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
6920                 }
6921                 if (r->parameters) {
6922                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6923                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6924                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6925                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6926                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6927                                 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));
6928                         }
6929                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6930                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6931                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6932                 }
6933                 if (r->secdesc) {
6934                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
6935                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
6936                         {
6937                                 struct ndr_pull *_ndr_secdesc;
6938                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6939                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6940                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6941                         }
6942                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
6943                 }
6944         }
6945         return NDR_ERR_SUCCESS;
6946 }
6947
6948 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
6949 {
6950         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
6951         ndr->depth++;
6952         ndr_print_ptr(ndr, "servername", r->servername);
6953         ndr->depth++;
6954         if (r->servername) {
6955                 ndr_print_string(ndr, "servername", r->servername);
6956         }
6957         ndr->depth--;
6958         ndr_print_ptr(ndr, "printername", r->printername);
6959         ndr->depth++;
6960         if (r->printername) {
6961                 ndr_print_string(ndr, "printername", r->printername);
6962         }
6963         ndr->depth--;
6964         ndr_print_ptr(ndr, "sharename", r->sharename);
6965         ndr->depth++;
6966         if (r->sharename) {
6967                 ndr_print_string(ndr, "sharename", r->sharename);
6968         }
6969         ndr->depth--;
6970         ndr_print_ptr(ndr, "portname", r->portname);
6971         ndr->depth++;
6972         if (r->portname) {
6973                 ndr_print_string(ndr, "portname", r->portname);
6974         }
6975         ndr->depth--;
6976         ndr_print_ptr(ndr, "drivername", r->drivername);
6977         ndr->depth++;
6978         if (r->drivername) {
6979                 ndr_print_string(ndr, "drivername", r->drivername);
6980         }
6981         ndr->depth--;
6982         ndr_print_ptr(ndr, "comment", r->comment);
6983         ndr->depth++;
6984         if (r->comment) {
6985                 ndr_print_string(ndr, "comment", r->comment);
6986         }
6987         ndr->depth--;
6988         ndr_print_ptr(ndr, "location", r->location);
6989         ndr->depth++;
6990         if (r->location) {
6991                 ndr_print_string(ndr, "location", r->location);
6992         }
6993         ndr->depth--;
6994         ndr_print_ptr(ndr, "devmode", r->devmode);
6995         ndr->depth++;
6996         if (r->devmode) {
6997                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
6998         }
6999         ndr->depth--;
7000         ndr_print_ptr(ndr, "sepfile", r->sepfile);
7001         ndr->depth++;
7002         if (r->sepfile) {
7003                 ndr_print_string(ndr, "sepfile", r->sepfile);
7004         }
7005         ndr->depth--;
7006         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
7007         ndr->depth++;
7008         if (r->printprocessor) {
7009                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
7010         }
7011         ndr->depth--;
7012         ndr_print_ptr(ndr, "datatype", r->datatype);
7013         ndr->depth++;
7014         if (r->datatype) {
7015                 ndr_print_string(ndr, "datatype", r->datatype);
7016         }
7017         ndr->depth--;
7018         ndr_print_ptr(ndr, "parameters", r->parameters);
7019         ndr->depth++;
7020         if (r->parameters) {
7021                 ndr_print_string(ndr, "parameters", r->parameters);
7022         }
7023         ndr->depth--;
7024         ndr_print_ptr(ndr, "secdesc", r->secdesc);
7025         ndr->depth++;
7026         if (r->secdesc) {
7027                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
7028         }
7029         ndr->depth--;
7030         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7031         ndr_print_uint32(ndr, "priority", r->priority);
7032         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
7033         ndr_print_uint32(ndr, "starttime", r->starttime);
7034         ndr_print_uint32(ndr, "untiltime", r->untiltime);
7035         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7036         ndr_print_uint32(ndr, "cjobs", r->cjobs);
7037         ndr_print_uint32(ndr, "averageppm", r->averageppm);
7038         ndr->depth--;
7039 }
7040
7041 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
7042 {
7043         if (ndr_flags & NDR_SCALARS) {
7044                 NDR_CHECK(ndr_push_align(ndr, 4));
7045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
7046         }
7047         if (ndr_flags & NDR_BUFFERS) {
7048         }
7049         return NDR_ERR_SUCCESS;
7050 }
7051
7052 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
7053 {
7054         if (ndr_flags & NDR_SCALARS) {
7055                 NDR_CHECK(ndr_pull_align(ndr, 4));
7056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
7057         }
7058         if (ndr_flags & NDR_BUFFERS) {
7059         }
7060         return NDR_ERR_SUCCESS;
7061 }
7062
7063 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
7064 {
7065         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
7066         ndr->depth++;
7067         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
7068         ndr->depth--;
7069 }
7070
7071 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
7072 {
7073         if (ndr_flags & NDR_SCALARS) {
7074                 NDR_CHECK(ndr_push_align(ndr, 4));
7075                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7076                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
7077                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7078         }
7079         if (ndr_flags & NDR_BUFFERS) {
7080                 if (r->printername) {
7081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7083                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7084                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7085                 }
7086                 if (r->servername) {
7087                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7088                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7089                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7090                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7091                 }
7092         }
7093         return NDR_ERR_SUCCESS;
7094 }
7095
7096 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
7097 {
7098         uint32_t _ptr_printername;
7099         TALLOC_CTX *_mem_save_printername_0;
7100         uint32_t _ptr_servername;
7101         TALLOC_CTX *_mem_save_servername_0;
7102         if (ndr_flags & NDR_SCALARS) {
7103                 NDR_CHECK(ndr_pull_align(ndr, 4));
7104                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7105                 if (_ptr_printername) {
7106                         NDR_PULL_ALLOC(ndr, r->printername);
7107                 } else {
7108                         r->printername = NULL;
7109                 }
7110                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
7111                 if (_ptr_servername) {
7112                         NDR_PULL_ALLOC(ndr, r->servername);
7113                 } else {
7114                         r->servername = NULL;
7115                 }
7116                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7117         }
7118         if (ndr_flags & NDR_BUFFERS) {
7119                 if (r->printername) {
7120                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7121                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7122                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7123                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7124                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7125                                 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));
7126                         }
7127                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7128                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7129                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7130                 }
7131                 if (r->servername) {
7132                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7133                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7134                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7135                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7136                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7137                                 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));
7138                         }
7139                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7140                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7141                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7142                 }
7143         }
7144         return NDR_ERR_SUCCESS;
7145 }
7146
7147 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
7148 {
7149         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
7150         ndr->depth++;
7151         ndr_print_ptr(ndr, "printername", r->printername);
7152         ndr->depth++;
7153         if (r->printername) {
7154                 ndr_print_string(ndr, "printername", r->printername);
7155         }
7156         ndr->depth--;
7157         ndr_print_ptr(ndr, "servername", r->servername);
7158         ndr->depth++;
7159         if (r->servername) {
7160                 ndr_print_string(ndr, "servername", r->servername);
7161         }
7162         ndr->depth--;
7163         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7164         ndr->depth--;
7165 }
7166
7167 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
7168 {
7169         if (ndr_flags & NDR_SCALARS) {
7170                 NDR_CHECK(ndr_push_align(ndr, 4));
7171                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7172                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
7173                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
7175                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
7176         }
7177         if (ndr_flags & NDR_BUFFERS) {
7178                 if (r->printername) {
7179                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7180                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7181                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7182                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7183                 }
7184                 if (r->portname) {
7185                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7186                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7187                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7188                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7189                 }
7190         }
7191         return NDR_ERR_SUCCESS;
7192 }
7193
7194 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
7195 {
7196         uint32_t _ptr_printername;
7197         TALLOC_CTX *_mem_save_printername_0;
7198         uint32_t _ptr_portname;
7199         TALLOC_CTX *_mem_save_portname_0;
7200         if (ndr_flags & NDR_SCALARS) {
7201                 NDR_CHECK(ndr_pull_align(ndr, 4));
7202                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7203                 if (_ptr_printername) {
7204                         NDR_PULL_ALLOC(ndr, r->printername);
7205                 } else {
7206                         r->printername = NULL;
7207                 }
7208                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
7209                 if (_ptr_portname) {
7210                         NDR_PULL_ALLOC(ndr, r->portname);
7211                 } else {
7212                         r->portname = NULL;
7213                 }
7214                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7215                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
7216                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
7217         }
7218         if (ndr_flags & NDR_BUFFERS) {
7219                 if (r->printername) {
7220                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7221                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7222                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7223                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7224                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7225                                 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));
7226                         }
7227                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7228                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7229                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7230                 }
7231                 if (r->portname) {
7232                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7233                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7234                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7235                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7236                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7237                                 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));
7238                         }
7239                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7240                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7241                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7242                 }
7243         }
7244         return NDR_ERR_SUCCESS;
7245 }
7246
7247 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
7248 {
7249         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
7250         ndr->depth++;
7251         ndr_print_ptr(ndr, "printername", r->printername);
7252         ndr->depth++;
7253         if (r->printername) {
7254                 ndr_print_string(ndr, "printername", r->printername);
7255         }
7256         ndr->depth--;
7257         ndr_print_ptr(ndr, "portname", r->portname);
7258         ndr->depth++;
7259         if (r->portname) {
7260                 ndr_print_string(ndr, "portname", r->portname);
7261         }
7262         ndr->depth--;
7263         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7264         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
7265         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
7266         ndr->depth--;
7267 }
7268
7269 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
7270 {
7271         if (ndr_flags & NDR_SCALARS) {
7272                 NDR_CHECK(ndr_push_align(ndr, 4));
7273                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
7274         }
7275         if (ndr_flags & NDR_BUFFERS) {
7276         }
7277         return NDR_ERR_SUCCESS;
7278 }
7279
7280 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
7281 {
7282         if (ndr_flags & NDR_SCALARS) {
7283                 NDR_CHECK(ndr_pull_align(ndr, 4));
7284                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7285         }
7286         if (ndr_flags & NDR_BUFFERS) {
7287         }
7288         return NDR_ERR_SUCCESS;
7289 }
7290
7291 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
7292 {
7293         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
7294         ndr->depth++;
7295         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7296         ndr->depth--;
7297 }
7298
7299 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
7300 {
7301         if (ndr_flags & NDR_SCALARS) {
7302                 NDR_CHECK(ndr_push_align(ndr, 4));
7303                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
7304                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
7305         }
7306         if (ndr_flags & NDR_BUFFERS) {
7307                 if (r->guid) {
7308                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7309                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7310                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7311                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7312                 }
7313         }
7314         return NDR_ERR_SUCCESS;
7315 }
7316
7317 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
7318 {
7319         uint32_t _ptr_guid;
7320         TALLOC_CTX *_mem_save_guid_0;
7321         if (ndr_flags & NDR_SCALARS) {
7322                 NDR_CHECK(ndr_pull_align(ndr, 4));
7323                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
7324                 if (_ptr_guid) {
7325                         NDR_PULL_ALLOC(ndr, r->guid);
7326                 } else {
7327                         r->guid = NULL;
7328                 }
7329                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
7330         }
7331         if (ndr_flags & NDR_BUFFERS) {
7332                 if (r->guid) {
7333                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7334                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
7335                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
7336                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
7337                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
7338                                 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));
7339                         }
7340                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
7341                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
7342                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
7343                 }
7344         }
7345         return NDR_ERR_SUCCESS;
7346 }
7347
7348 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
7349 {
7350         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
7351         ndr->depth++;
7352         ndr_print_ptr(ndr, "guid", r->guid);
7353         ndr->depth++;
7354         if (r->guid) {
7355                 ndr_print_string(ndr, "guid", r->guid);
7356         }
7357         ndr->depth--;
7358         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
7359         ndr->depth--;
7360 }
7361
7362 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
7363 {
7364         if (ndr_flags & NDR_SCALARS) {
7365                 int level = ndr_push_get_switch_value(ndr, r);
7366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
7367                 switch (level) {
7368                         case 0: {
7369                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
7370                         break; }
7371
7372                         case 1: {
7373                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
7374                         break; }
7375
7376                         case 2: {
7377                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
7378                         break; }
7379
7380                         case 3: {
7381                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
7382                         break; }
7383
7384                         case 4: {
7385                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
7386                         break; }
7387
7388                         case 5: {
7389                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
7390                         break; }
7391
7392                         case 6: {
7393                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
7394                         break; }
7395
7396                         case 7: {
7397                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
7398                         break; }
7399
7400                         case 8: {
7401                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
7402                         break; }
7403
7404                         case 9: {
7405                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
7406                         break; }
7407
7408                         default: {
7409                         break; }
7410
7411                 }
7412         }
7413         if (ndr_flags & NDR_BUFFERS) {
7414                 int level = ndr_push_get_switch_value(ndr, r);
7415                 switch (level) {
7416                         case 0:
7417                                 if (r->info0) {
7418                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7419                                 }
7420                         break;
7421
7422                         case 1:
7423                                 if (r->info1) {
7424                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7425                                 }
7426                         break;
7427
7428                         case 2:
7429                                 if (r->info2) {
7430                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7431                                 }
7432                         break;
7433
7434                         case 3:
7435                                 if (r->info3) {
7436                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7437                                 }
7438                         break;
7439
7440                         case 4:
7441                                 if (r->info4) {
7442                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7443                                 }
7444                         break;
7445
7446                         case 5:
7447                                 if (r->info5) {
7448                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7449                                 }
7450                         break;
7451
7452                         case 6:
7453                                 if (r->info6) {
7454                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7455                                 }
7456                         break;
7457
7458                         case 7:
7459                                 if (r->info7) {
7460                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7461                                 }
7462                         break;
7463
7464                         case 8:
7465                                 if (r->info8) {
7466                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7467                                 }
7468                         break;
7469
7470                         case 9:
7471                                 if (r->info9) {
7472                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7473                                 }
7474                         break;
7475
7476                         default:
7477                         break;
7478
7479                 }
7480         }
7481         return NDR_ERR_SUCCESS;
7482 }
7483
7484 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
7485 {
7486         int level;
7487         uint32_t _level;
7488         TALLOC_CTX *_mem_save_info0_0;
7489         TALLOC_CTX *_mem_save_info1_0;
7490         TALLOC_CTX *_mem_save_info2_0;
7491         TALLOC_CTX *_mem_save_info3_0;
7492         TALLOC_CTX *_mem_save_info4_0;
7493         TALLOC_CTX *_mem_save_info5_0;
7494         TALLOC_CTX *_mem_save_info6_0;
7495         TALLOC_CTX *_mem_save_info7_0;
7496         TALLOC_CTX *_mem_save_info8_0;
7497         TALLOC_CTX *_mem_save_info9_0;
7498         level = ndr_pull_get_switch_value(ndr, r);
7499         if (ndr_flags & NDR_SCALARS) {
7500                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7501                 if (_level != level) {
7502                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
7503                 }
7504                 switch (level) {
7505                         case 0: {
7506                                 uint32_t _ptr_info0;
7507                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
7508                                 if (_ptr_info0) {
7509                                         NDR_PULL_ALLOC(ndr, r->info0);
7510                                 } else {
7511                                         r->info0 = NULL;
7512                                 }
7513                         break; }
7514
7515                         case 1: {
7516                                 uint32_t _ptr_info1;
7517                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
7518                                 if (_ptr_info1) {
7519                                         NDR_PULL_ALLOC(ndr, r->info1);
7520                                 } else {
7521                                         r->info1 = NULL;
7522                                 }
7523                         break; }
7524
7525                         case 2: {
7526                                 uint32_t _ptr_info2;
7527                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
7528                                 if (_ptr_info2) {
7529                                         NDR_PULL_ALLOC(ndr, r->info2);
7530                                 } else {
7531                                         r->info2 = NULL;
7532                                 }
7533                         break; }
7534
7535                         case 3: {
7536                                 uint32_t _ptr_info3;
7537                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7538                                 if (_ptr_info3) {
7539                                         NDR_PULL_ALLOC(ndr, r->info3);
7540                                 } else {
7541                                         r->info3 = NULL;
7542                                 }
7543                         break; }
7544
7545                         case 4: {
7546                                 uint32_t _ptr_info4;
7547                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7548                                 if (_ptr_info4) {
7549                                         NDR_PULL_ALLOC(ndr, r->info4);
7550                                 } else {
7551                                         r->info4 = NULL;
7552                                 }
7553                         break; }
7554
7555                         case 5: {
7556                                 uint32_t _ptr_info5;
7557                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7558                                 if (_ptr_info5) {
7559                                         NDR_PULL_ALLOC(ndr, r->info5);
7560                                 } else {
7561                                         r->info5 = NULL;
7562                                 }
7563                         break; }
7564
7565                         case 6: {
7566                                 uint32_t _ptr_info6;
7567                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7568                                 if (_ptr_info6) {
7569                                         NDR_PULL_ALLOC(ndr, r->info6);
7570                                 } else {
7571                                         r->info6 = NULL;
7572                                 }
7573                         break; }
7574
7575                         case 7: {
7576                                 uint32_t _ptr_info7;
7577                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7578                                 if (_ptr_info7) {
7579                                         NDR_PULL_ALLOC(ndr, r->info7);
7580                                 } else {
7581                                         r->info7 = NULL;
7582                                 }
7583                         break; }
7584
7585                         case 8: {
7586                                 uint32_t _ptr_info8;
7587                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7588                                 if (_ptr_info8) {
7589                                         NDR_PULL_ALLOC(ndr, r->info8);
7590                                 } else {
7591                                         r->info8 = NULL;
7592                                 }
7593                         break; }
7594
7595                         case 9: {
7596                                 uint32_t _ptr_info9;
7597                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7598                                 if (_ptr_info9) {
7599                                         NDR_PULL_ALLOC(ndr, r->info9);
7600                                 } else {
7601                                         r->info9 = NULL;
7602                                 }
7603                         break; }
7604
7605                         default: {
7606                         break; }
7607
7608                 }
7609         }
7610         if (ndr_flags & NDR_BUFFERS) {
7611                 switch (level) {
7612                         case 0:
7613                                 if (r->info0) {
7614                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7615                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7616                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7617                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7618                                 }
7619                         break;
7620
7621                         case 1:
7622                                 if (r->info1) {
7623                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7624                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7625                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7626                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7627                                 }
7628                         break;
7629
7630                         case 2:
7631                                 if (r->info2) {
7632                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7633                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7634                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7635                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7636                                 }
7637                         break;
7638
7639                         case 3:
7640                                 if (r->info3) {
7641                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7642                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7643                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7644                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7645                                 }
7646                         break;
7647
7648                         case 4:
7649                                 if (r->info4) {
7650                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7651                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7652                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7653                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7654                                 }
7655                         break;
7656
7657                         case 5:
7658                                 if (r->info5) {
7659                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7660                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7661                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7662                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7663                                 }
7664                         break;
7665
7666                         case 6:
7667                                 if (r->info6) {
7668                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7669                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7670                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7671                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7672                                 }
7673                         break;
7674
7675                         case 7:
7676                                 if (r->info7) {
7677                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7678                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7679                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7680                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7681                                 }
7682                         break;
7683
7684                         case 8:
7685                                 if (r->info8) {
7686                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7687                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7688                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7689                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7690                                 }
7691                         break;
7692
7693                         case 9:
7694                                 if (r->info9) {
7695                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7696                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7697                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7698                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7699                                 }
7700                         break;
7701
7702                         default:
7703                         break;
7704
7705                 }
7706         }
7707         return NDR_ERR_SUCCESS;
7708 }
7709
7710 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7711 {
7712         int level;
7713         level = ndr_print_get_switch_value(ndr, r);
7714         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7715         switch (level) {
7716                 case 0:
7717                         ndr_print_ptr(ndr, "info0", r->info0);
7718                         ndr->depth++;
7719                         if (r->info0) {
7720                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
7721                         }
7722                         ndr->depth--;
7723                 break;
7724
7725                 case 1:
7726                         ndr_print_ptr(ndr, "info1", r->info1);
7727                         ndr->depth++;
7728                         if (r->info1) {
7729                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
7730                         }
7731                         ndr->depth--;
7732                 break;
7733
7734                 case 2:
7735                         ndr_print_ptr(ndr, "info2", r->info2);
7736                         ndr->depth++;
7737                         if (r->info2) {
7738                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
7739                         }
7740                         ndr->depth--;
7741                 break;
7742
7743                 case 3:
7744                         ndr_print_ptr(ndr, "info3", r->info3);
7745                         ndr->depth++;
7746                         if (r->info3) {
7747                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
7748                         }
7749                         ndr->depth--;
7750                 break;
7751
7752                 case 4:
7753                         ndr_print_ptr(ndr, "info4", r->info4);
7754                         ndr->depth++;
7755                         if (r->info4) {
7756                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
7757                         }
7758                         ndr->depth--;
7759                 break;
7760
7761                 case 5:
7762                         ndr_print_ptr(ndr, "info5", r->info5);
7763                         ndr->depth++;
7764                         if (r->info5) {
7765                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
7766                         }
7767                         ndr->depth--;
7768                 break;
7769
7770                 case 6:
7771                         ndr_print_ptr(ndr, "info6", r->info6);
7772                         ndr->depth++;
7773                         if (r->info6) {
7774                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
7775                         }
7776                         ndr->depth--;
7777                 break;
7778
7779                 case 7:
7780                         ndr_print_ptr(ndr, "info7", r->info7);
7781                         ndr->depth++;
7782                         if (r->info7) {
7783                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
7784                         }
7785                         ndr->depth--;
7786                 break;
7787
7788                 case 8:
7789                         ndr_print_ptr(ndr, "info8", r->info8);
7790                         ndr->depth++;
7791                         if (r->info8) {
7792                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
7793                         }
7794                         ndr->depth--;
7795                 break;
7796
7797                 case 9:
7798                         ndr_print_ptr(ndr, "info9", r->info9);
7799                         ndr->depth++;
7800                         if (r->info9) {
7801                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
7802                         }
7803                         ndr->depth--;
7804                 break;
7805
7806                 default:
7807                 break;
7808
7809         }
7810 }
7811
7812 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
7813 {
7814         if (ndr_flags & NDR_SCALARS) {
7815                 NDR_CHECK(ndr_push_align(ndr, 4));
7816                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7817                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
7818                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7819         }
7820         if (ndr_flags & NDR_BUFFERS) {
7821                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7822         }
7823         return NDR_ERR_SUCCESS;
7824 }
7825
7826 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
7827 {
7828         if (ndr_flags & NDR_SCALARS) {
7829                 NDR_CHECK(ndr_pull_align(ndr, 4));
7830                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7831                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
7832                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7833         }
7834         if (ndr_flags & NDR_BUFFERS) {
7835                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7836         }
7837         return NDR_ERR_SUCCESS;
7838 }
7839
7840 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
7841 {
7842         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
7843         ndr->depth++;
7844         ndr_print_uint32(ndr, "level", r->level);
7845         ndr_print_set_switch_value(ndr, &r->info, r->level);
7846         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
7847         ndr->depth--;
7848 }
7849
7850 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
7851 {
7852         if (ndr_flags & NDR_SCALARS) {
7853                 NDR_CHECK(ndr_push_align(ndr, 4));
7854                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
7855                 {
7856                         uint32_t _flags_save_string_array = ndr->flags;
7857                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7858                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
7859                         ndr->flags = _flags_save_string_array;
7860                 }
7861         }
7862         if (ndr_flags & NDR_BUFFERS) {
7863         }
7864         return NDR_ERR_SUCCESS;
7865 }
7866
7867 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
7868 {
7869         if (ndr_flags & NDR_SCALARS) {
7870                 NDR_CHECK(ndr_pull_align(ndr, 4));
7871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
7872                 {
7873                         uint32_t _flags_save_string_array = ndr->flags;
7874                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7875                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
7876                         ndr->flags = _flags_save_string_array;
7877                 }
7878         }
7879         if (ndr_flags & NDR_BUFFERS) {
7880         }
7881         return NDR_ERR_SUCCESS;
7882 }
7883
7884 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
7885 {
7886         ndr_print_struct(ndr, name, "spoolss_StringArray");
7887         ndr->depth++;
7888         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);
7889         ndr_print_string_array(ndr, "string", r->string);
7890         ndr->depth--;
7891 }
7892
7893 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
7894 {
7895         if (ndr_flags & NDR_SCALARS) {
7896                 NDR_CHECK(ndr_push_align(ndr, 4));
7897                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7898         }
7899         if (ndr_flags & NDR_BUFFERS) {
7900                 if (r->driver_name) {
7901                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7902                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7903                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7904                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7905                 }
7906         }
7907         return NDR_ERR_SUCCESS;
7908 }
7909
7910 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
7911 {
7912         uint32_t _ptr_driver_name;
7913         TALLOC_CTX *_mem_save_driver_name_0;
7914         if (ndr_flags & NDR_SCALARS) {
7915                 NDR_CHECK(ndr_pull_align(ndr, 4));
7916                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7917                 if (_ptr_driver_name) {
7918                         NDR_PULL_ALLOC(ndr, r->driver_name);
7919                 } else {
7920                         r->driver_name = NULL;
7921                 }
7922         }
7923         if (ndr_flags & NDR_BUFFERS) {
7924                 if (r->driver_name) {
7925                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7926                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7927                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7928                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7929                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7930                                 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));
7931                         }
7932                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7933                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7934                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7935                 }
7936         }
7937         return NDR_ERR_SUCCESS;
7938 }
7939
7940 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
7941 {
7942         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
7943         ndr->depth++;
7944         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7945         ndr->depth++;
7946         if (r->driver_name) {
7947                 ndr_print_string(ndr, "driver_name", r->driver_name);
7948         }
7949         ndr->depth--;
7950         ndr->depth--;
7951 }
7952
7953 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
7954 {
7955         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
7956         return NDR_ERR_SUCCESS;
7957 }
7958
7959 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
7960 {
7961         uint32_t v;
7962         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
7963         *r = v;
7964         return NDR_ERR_SUCCESS;
7965 }
7966
7967 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
7968 {
7969         const char *val = NULL;
7970
7971         switch (r) {
7972                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
7973                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
7974                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
7975                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
7976         }
7977         ndr_print_enum(ndr, name, "ENUM", val, r);
7978 }
7979
7980 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
7981 {
7982         if (ndr_flags & NDR_SCALARS) {
7983                 NDR_CHECK(ndr_push_align(ndr, 4));
7984                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7985                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7986                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7987                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7988                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7989                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7990         }
7991         if (ndr_flags & NDR_BUFFERS) {
7992                 if (r->driver_name) {
7993                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7994                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7995                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7996                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7997                 }
7998                 if (r->architecture) {
7999                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8000                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8001                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8002                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8003                 }
8004                 if (r->driver_path) {
8005                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8006                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8007                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8008                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8009                 }
8010                 if (r->data_file) {
8011                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, 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->data_file, CH_UTF16)));
8014                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8015                 }
8016                 if (r->config_file) {
8017                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, 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->config_file, CH_UTF16)));
8020                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8021                 }
8022         }
8023         return NDR_ERR_SUCCESS;
8024 }
8025
8026 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
8027 {
8028         uint32_t _ptr_driver_name;
8029         TALLOC_CTX *_mem_save_driver_name_0;
8030         uint32_t _ptr_architecture;
8031         TALLOC_CTX *_mem_save_architecture_0;
8032         uint32_t _ptr_driver_path;
8033         TALLOC_CTX *_mem_save_driver_path_0;
8034         uint32_t _ptr_data_file;
8035         TALLOC_CTX *_mem_save_data_file_0;
8036         uint32_t _ptr_config_file;
8037         TALLOC_CTX *_mem_save_config_file_0;
8038         if (ndr_flags & NDR_SCALARS) {
8039                 NDR_CHECK(ndr_pull_align(ndr, 4));
8040                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8041                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8042                 if (_ptr_driver_name) {
8043                         NDR_PULL_ALLOC(ndr, r->driver_name);
8044                 } else {
8045                         r->driver_name = NULL;
8046                 }
8047                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8048                 if (_ptr_architecture) {
8049                         NDR_PULL_ALLOC(ndr, r->architecture);
8050                 } else {
8051                         r->architecture = NULL;
8052                 }
8053                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8054                 if (_ptr_driver_path) {
8055                         NDR_PULL_ALLOC(ndr, r->driver_path);
8056                 } else {
8057                         r->driver_path = NULL;
8058                 }
8059                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8060                 if (_ptr_data_file) {
8061                         NDR_PULL_ALLOC(ndr, r->data_file);
8062                 } else {
8063                         r->data_file = NULL;
8064                 }
8065                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8066                 if (_ptr_config_file) {
8067                         NDR_PULL_ALLOC(ndr, r->config_file);
8068                 } else {
8069                         r->config_file = NULL;
8070                 }
8071         }
8072         if (ndr_flags & NDR_BUFFERS) {
8073                 if (r->driver_name) {
8074                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8075                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8076                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8077                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8078                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8079                                 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));
8080                         }
8081                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8082                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8083                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8084                 }
8085                 if (r->architecture) {
8086                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8087                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8088                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8089                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8090                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8091                                 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));
8092                         }
8093                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8094                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8095                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8096                 }
8097                 if (r->driver_path) {
8098                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8099                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8100                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8101                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8102                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8103                                 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));
8104                         }
8105                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8106                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8107                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8108                 }
8109                 if (r->data_file) {
8110                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8111                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8112                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8113                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8114                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8115                                 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));
8116                         }
8117                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8118                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8119                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8120                 }
8121                 if (r->config_file) {
8122                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8123                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8124                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8125                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8126                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8127                                 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));
8128                         }
8129                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8130                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8131                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8132                 }
8133         }
8134         return NDR_ERR_SUCCESS;
8135 }
8136
8137 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
8138 {
8139         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
8140         ndr->depth++;
8141         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8142         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8143         ndr->depth++;
8144         if (r->driver_name) {
8145                 ndr_print_string(ndr, "driver_name", r->driver_name);
8146         }
8147         ndr->depth--;
8148         ndr_print_ptr(ndr, "architecture", r->architecture);
8149         ndr->depth++;
8150         if (r->architecture) {
8151                 ndr_print_string(ndr, "architecture", r->architecture);
8152         }
8153         ndr->depth--;
8154         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8155         ndr->depth++;
8156         if (r->driver_path) {
8157                 ndr_print_string(ndr, "driver_path", r->driver_path);
8158         }
8159         ndr->depth--;
8160         ndr_print_ptr(ndr, "data_file", r->data_file);
8161         ndr->depth++;
8162         if (r->data_file) {
8163                 ndr_print_string(ndr, "data_file", r->data_file);
8164         }
8165         ndr->depth--;
8166         ndr_print_ptr(ndr, "config_file", r->config_file);
8167         ndr->depth++;
8168         if (r->config_file) {
8169                 ndr_print_string(ndr, "config_file", r->config_file);
8170         }
8171         ndr->depth--;
8172         ndr->depth--;
8173 }
8174
8175 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
8176 {
8177         if (ndr_flags & NDR_SCALARS) {
8178                 NDR_CHECK(ndr_push_align(ndr, 4));
8179                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8180                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8181                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8182                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8183                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8184                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8185                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8186                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8187                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8188                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8189                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8190         }
8191         if (ndr_flags & NDR_BUFFERS) {
8192                 if (r->driver_name) {
8193                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8194                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8195                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8196                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8197                 }
8198                 if (r->architecture) {
8199                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8200                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8201                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8202                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8203                 }
8204                 if (r->driver_path) {
8205                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8206                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8207                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8208                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8209                 }
8210                 if (r->data_file) {
8211                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8212                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8213                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8214                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8215                 }
8216                 if (r->config_file) {
8217                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8218                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8219                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8220                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8221                 }
8222                 if (r->help_file) {
8223                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8224                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8225                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8226                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8227                 }
8228                 if (r->monitor_name) {
8229                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8230                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8231                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8232                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8233                 }
8234                 if (r->default_datatype) {
8235                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8236                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8237                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8238                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8239                 }
8240                 if (r->dependent_files) {
8241                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8242                 }
8243         }
8244         return NDR_ERR_SUCCESS;
8245 }
8246
8247 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
8248 {
8249         uint32_t _ptr_driver_name;
8250         TALLOC_CTX *_mem_save_driver_name_0;
8251         uint32_t _ptr_architecture;
8252         TALLOC_CTX *_mem_save_architecture_0;
8253         uint32_t _ptr_driver_path;
8254         TALLOC_CTX *_mem_save_driver_path_0;
8255         uint32_t _ptr_data_file;
8256         TALLOC_CTX *_mem_save_data_file_0;
8257         uint32_t _ptr_config_file;
8258         TALLOC_CTX *_mem_save_config_file_0;
8259         uint32_t _ptr_help_file;
8260         TALLOC_CTX *_mem_save_help_file_0;
8261         uint32_t _ptr_monitor_name;
8262         TALLOC_CTX *_mem_save_monitor_name_0;
8263         uint32_t _ptr_default_datatype;
8264         TALLOC_CTX *_mem_save_default_datatype_0;
8265         uint32_t _ptr_dependent_files;
8266         TALLOC_CTX *_mem_save_dependent_files_0;
8267         if (ndr_flags & NDR_SCALARS) {
8268                 NDR_CHECK(ndr_pull_align(ndr, 4));
8269                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8270                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8271                 if (_ptr_driver_name) {
8272                         NDR_PULL_ALLOC(ndr, r->driver_name);
8273                 } else {
8274                         r->driver_name = NULL;
8275                 }
8276                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8277                 if (_ptr_architecture) {
8278                         NDR_PULL_ALLOC(ndr, r->architecture);
8279                 } else {
8280                         r->architecture = NULL;
8281                 }
8282                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8283                 if (_ptr_driver_path) {
8284                         NDR_PULL_ALLOC(ndr, r->driver_path);
8285                 } else {
8286                         r->driver_path = NULL;
8287                 }
8288                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8289                 if (_ptr_data_file) {
8290                         NDR_PULL_ALLOC(ndr, r->data_file);
8291                 } else {
8292                         r->data_file = NULL;
8293                 }
8294                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8295                 if (_ptr_config_file) {
8296                         NDR_PULL_ALLOC(ndr, r->config_file);
8297                 } else {
8298                         r->config_file = NULL;
8299                 }
8300                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8301                 if (_ptr_help_file) {
8302                         NDR_PULL_ALLOC(ndr, r->help_file);
8303                 } else {
8304                         r->help_file = NULL;
8305                 }
8306                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8307                 if (_ptr_monitor_name) {
8308                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8309                 } else {
8310                         r->monitor_name = NULL;
8311                 }
8312                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8313                 if (_ptr_default_datatype) {
8314                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8315                 } else {
8316                         r->default_datatype = NULL;
8317                 }
8318                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8319                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8320                 if (_ptr_dependent_files) {
8321                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8322                 } else {
8323                         r->dependent_files = NULL;
8324                 }
8325         }
8326         if (ndr_flags & NDR_BUFFERS) {
8327                 if (r->driver_name) {
8328                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8329                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8330                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8331                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8332                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8333                                 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));
8334                         }
8335                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8336                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8337                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8338                 }
8339                 if (r->architecture) {
8340                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8341                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8342                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8343                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8344                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8345                                 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));
8346                         }
8347                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8348                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8349                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8350                 }
8351                 if (r->driver_path) {
8352                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8353                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8354                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8355                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8356                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8357                                 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));
8358                         }
8359                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8360                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8361                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8362                 }
8363                 if (r->data_file) {
8364                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8365                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8366                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8367                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8368                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8369                                 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));
8370                         }
8371                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8372                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8373                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8374                 }
8375                 if (r->config_file) {
8376                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8377                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8378                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8379                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8380                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8381                                 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));
8382                         }
8383                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8384                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8385                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8386                 }
8387                 if (r->help_file) {
8388                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8389                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8390                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8391                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8392                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8393                                 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));
8394                         }
8395                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8396                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8397                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8398                 }
8399                 if (r->monitor_name) {
8400                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8401                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8402                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8403                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8404                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8405                                 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));
8406                         }
8407                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8408                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8409                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8410                 }
8411                 if (r->default_datatype) {
8412                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8413                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8414                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8415                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8416                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8417                                 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));
8418                         }
8419                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8420                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8421                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8422                 }
8423                 if (r->dependent_files) {
8424                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8425                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8426                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8427                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8428                 }
8429         }
8430         return NDR_ERR_SUCCESS;
8431 }
8432
8433 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
8434 {
8435         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
8436         ndr->depth++;
8437         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8438         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8439         ndr->depth++;
8440         if (r->driver_name) {
8441                 ndr_print_string(ndr, "driver_name", r->driver_name);
8442         }
8443         ndr->depth--;
8444         ndr_print_ptr(ndr, "architecture", r->architecture);
8445         ndr->depth++;
8446         if (r->architecture) {
8447                 ndr_print_string(ndr, "architecture", r->architecture);
8448         }
8449         ndr->depth--;
8450         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8451         ndr->depth++;
8452         if (r->driver_path) {
8453                 ndr_print_string(ndr, "driver_path", r->driver_path);
8454         }
8455         ndr->depth--;
8456         ndr_print_ptr(ndr, "data_file", r->data_file);
8457         ndr->depth++;
8458         if (r->data_file) {
8459                 ndr_print_string(ndr, "data_file", r->data_file);
8460         }
8461         ndr->depth--;
8462         ndr_print_ptr(ndr, "config_file", r->config_file);
8463         ndr->depth++;
8464         if (r->config_file) {
8465                 ndr_print_string(ndr, "config_file", r->config_file);
8466         }
8467         ndr->depth--;
8468         ndr_print_ptr(ndr, "help_file", r->help_file);
8469         ndr->depth++;
8470         if (r->help_file) {
8471                 ndr_print_string(ndr, "help_file", r->help_file);
8472         }
8473         ndr->depth--;
8474         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8475         ndr->depth++;
8476         if (r->monitor_name) {
8477                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8478         }
8479         ndr->depth--;
8480         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8481         ndr->depth++;
8482         if (r->default_datatype) {
8483                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8484         }
8485         ndr->depth--;
8486         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);
8487         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8488         ndr->depth++;
8489         if (r->dependent_files) {
8490                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8491         }
8492         ndr->depth--;
8493         ndr->depth--;
8494 }
8495
8496 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
8497 {
8498         if (ndr_flags & NDR_SCALARS) {
8499                 NDR_CHECK(ndr_push_align(ndr, 4));
8500                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8501                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8502                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8503                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8504                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8505                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8506                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8507                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8508                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8509                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8510                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8512                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8513         }
8514         if (ndr_flags & NDR_BUFFERS) {
8515                 if (r->driver_name) {
8516                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8517                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8518                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8519                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8520                 }
8521                 if (r->architecture) {
8522                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8523                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8524                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8525                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8526                 }
8527                 if (r->driver_path) {
8528                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8529                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8530                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8531                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8532                 }
8533                 if (r->data_file) {
8534                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8535                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8536                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8537                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8538                 }
8539                 if (r->config_file) {
8540                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8541                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8542                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8543                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8544                 }
8545                 if (r->help_file) {
8546                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8547                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8548                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8549                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8550                 }
8551                 if (r->monitor_name) {
8552                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8553                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8554                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8555                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8556                 }
8557                 if (r->default_datatype) {
8558                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8559                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8560                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8561                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8562                 }
8563                 if (r->dependent_files) {
8564                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8565                 }
8566                 if (r->previous_names) {
8567                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8568                 }
8569         }
8570         return NDR_ERR_SUCCESS;
8571 }
8572
8573 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8574 {
8575         uint32_t _ptr_driver_name;
8576         TALLOC_CTX *_mem_save_driver_name_0;
8577         uint32_t _ptr_architecture;
8578         TALLOC_CTX *_mem_save_architecture_0;
8579         uint32_t _ptr_driver_path;
8580         TALLOC_CTX *_mem_save_driver_path_0;
8581         uint32_t _ptr_data_file;
8582         TALLOC_CTX *_mem_save_data_file_0;
8583         uint32_t _ptr_config_file;
8584         TALLOC_CTX *_mem_save_config_file_0;
8585         uint32_t _ptr_help_file;
8586         TALLOC_CTX *_mem_save_help_file_0;
8587         uint32_t _ptr_monitor_name;
8588         TALLOC_CTX *_mem_save_monitor_name_0;
8589         uint32_t _ptr_default_datatype;
8590         TALLOC_CTX *_mem_save_default_datatype_0;
8591         uint32_t _ptr_dependent_files;
8592         TALLOC_CTX *_mem_save_dependent_files_0;
8593         uint32_t _ptr_previous_names;
8594         TALLOC_CTX *_mem_save_previous_names_0;
8595         if (ndr_flags & NDR_SCALARS) {
8596                 NDR_CHECK(ndr_pull_align(ndr, 4));
8597                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8598                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8599                 if (_ptr_driver_name) {
8600                         NDR_PULL_ALLOC(ndr, r->driver_name);
8601                 } else {
8602                         r->driver_name = NULL;
8603                 }
8604                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8605                 if (_ptr_architecture) {
8606                         NDR_PULL_ALLOC(ndr, r->architecture);
8607                 } else {
8608                         r->architecture = NULL;
8609                 }
8610                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8611                 if (_ptr_driver_path) {
8612                         NDR_PULL_ALLOC(ndr, r->driver_path);
8613                 } else {
8614                         r->driver_path = NULL;
8615                 }
8616                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8617                 if (_ptr_data_file) {
8618                         NDR_PULL_ALLOC(ndr, r->data_file);
8619                 } else {
8620                         r->data_file = NULL;
8621                 }
8622                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8623                 if (_ptr_config_file) {
8624                         NDR_PULL_ALLOC(ndr, r->config_file);
8625                 } else {
8626                         r->config_file = NULL;
8627                 }
8628                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8629                 if (_ptr_help_file) {
8630                         NDR_PULL_ALLOC(ndr, r->help_file);
8631                 } else {
8632                         r->help_file = NULL;
8633                 }
8634                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8635                 if (_ptr_monitor_name) {
8636                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8637                 } else {
8638                         r->monitor_name = NULL;
8639                 }
8640                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8641                 if (_ptr_default_datatype) {
8642                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8643                 } else {
8644                         r->default_datatype = NULL;
8645                 }
8646                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8647                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8648                 if (_ptr_dependent_files) {
8649                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8650                 } else {
8651                         r->dependent_files = NULL;
8652                 }
8653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8654                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8655                 if (_ptr_previous_names) {
8656                         NDR_PULL_ALLOC(ndr, r->previous_names);
8657                 } else {
8658                         r->previous_names = NULL;
8659                 }
8660         }
8661         if (ndr_flags & NDR_BUFFERS) {
8662                 if (r->driver_name) {
8663                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8664                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8665                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8666                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8667                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8668                                 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));
8669                         }
8670                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8671                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8672                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8673                 }
8674                 if (r->architecture) {
8675                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8676                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8677                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8678                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8679                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8680                                 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));
8681                         }
8682                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8683                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8684                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8685                 }
8686                 if (r->driver_path) {
8687                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8688                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8689                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8690                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8691                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8692                                 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));
8693                         }
8694                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8695                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8696                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8697                 }
8698                 if (r->data_file) {
8699                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8700                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8701                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8702                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8703                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8704                                 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));
8705                         }
8706                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8707                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8708                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8709                 }
8710                 if (r->config_file) {
8711                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8712                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8713                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8714                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8715                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8716                                 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));
8717                         }
8718                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8719                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8720                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8721                 }
8722                 if (r->help_file) {
8723                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8724                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8725                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8726                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8727                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8728                                 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));
8729                         }
8730                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8731                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8732                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8733                 }
8734                 if (r->monitor_name) {
8735                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8736                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8737                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8738                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8739                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8740                                 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));
8741                         }
8742                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8743                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8744                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8745                 }
8746                 if (r->default_datatype) {
8747                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8748                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8749                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8750                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8751                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8752                                 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));
8753                         }
8754                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8755                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8756                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8757                 }
8758                 if (r->dependent_files) {
8759                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8760                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8761                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8762                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8763                 }
8764                 if (r->previous_names) {
8765                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8766                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8767                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8768                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8769                 }
8770         }
8771         return NDR_ERR_SUCCESS;
8772 }
8773
8774 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
8775 {
8776         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
8777         ndr->depth++;
8778         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8779         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8780         ndr->depth++;
8781         if (r->driver_name) {
8782                 ndr_print_string(ndr, "driver_name", r->driver_name);
8783         }
8784         ndr->depth--;
8785         ndr_print_ptr(ndr, "architecture", r->architecture);
8786         ndr->depth++;
8787         if (r->architecture) {
8788                 ndr_print_string(ndr, "architecture", r->architecture);
8789         }
8790         ndr->depth--;
8791         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8792         ndr->depth++;
8793         if (r->driver_path) {
8794                 ndr_print_string(ndr, "driver_path", r->driver_path);
8795         }
8796         ndr->depth--;
8797         ndr_print_ptr(ndr, "data_file", r->data_file);
8798         ndr->depth++;
8799         if (r->data_file) {
8800                 ndr_print_string(ndr, "data_file", r->data_file);
8801         }
8802         ndr->depth--;
8803         ndr_print_ptr(ndr, "config_file", r->config_file);
8804         ndr->depth++;
8805         if (r->config_file) {
8806                 ndr_print_string(ndr, "config_file", r->config_file);
8807         }
8808         ndr->depth--;
8809         ndr_print_ptr(ndr, "help_file", r->help_file);
8810         ndr->depth++;
8811         if (r->help_file) {
8812                 ndr_print_string(ndr, "help_file", r->help_file);
8813         }
8814         ndr->depth--;
8815         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8816         ndr->depth++;
8817         if (r->monitor_name) {
8818                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8819         }
8820         ndr->depth--;
8821         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8822         ndr->depth++;
8823         if (r->default_datatype) {
8824                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8825         }
8826         ndr->depth--;
8827         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);
8828         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8829         ndr->depth++;
8830         if (r->dependent_files) {
8831                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8832         }
8833         ndr->depth--;
8834         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);
8835         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8836         ndr->depth++;
8837         if (r->previous_names) {
8838                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8839         }
8840         ndr->depth--;
8841         ndr->depth--;
8842 }
8843
8844 static enum ndr_err_code ndr_push_spoolss_DriverAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
8845 {
8846         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
8847         return NDR_ERR_SUCCESS;
8848 }
8849
8850 static enum ndr_err_code ndr_pull_spoolss_DriverAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
8851 {
8852         uint32_t v;
8853         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
8854         *r = v;
8855         return NDR_ERR_SUCCESS;
8856 }
8857
8858 _PUBLIC_ void ndr_print_spoolss_DriverAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
8859 {
8860         ndr_print_uint32(ndr, name, r);
8861         ndr->depth++;
8862         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_DRIVER_PACKAGE_AWARE", PRINTER_DRIVER_PACKAGE_AWARE, r);
8863         ndr->depth--;
8864 }
8865
8866 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
8867 {
8868         if (ndr_flags & NDR_SCALARS) {
8869                 NDR_CHECK(ndr_push_align(ndr, 8));
8870                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8871                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8872                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8873                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8874                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8875                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8876                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8877                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8878                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8879                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8880                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8881                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8882                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8883                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8884                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8885                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8886                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8887                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8888                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8889         }
8890         if (ndr_flags & NDR_BUFFERS) {
8891                 if (r->driver_name) {
8892                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8893                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8894                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8895                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8896                 }
8897                 if (r->architecture) {
8898                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8899                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8900                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8901                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8902                 }
8903                 if (r->driver_path) {
8904                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8905                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8906                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8907                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8908                 }
8909                 if (r->data_file) {
8910                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8911                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8912                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8913                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8914                 }
8915                 if (r->config_file) {
8916                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8917                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8918                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8919                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8920                 }
8921                 if (r->help_file) {
8922                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8923                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8924                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8925                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8926                 }
8927                 if (r->monitor_name) {
8928                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8929                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8930                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8931                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8932                 }
8933                 if (r->default_datatype) {
8934                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8935                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8936                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8937                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8938                 }
8939                 if (r->dependent_files) {
8940                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8941                 }
8942                 if (r->previous_names) {
8943                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8944                 }
8945                 if (r->manufacturer_name) {
8946                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8947                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8948                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8949                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8950                 }
8951                 if (r->manufacturer_url) {
8952                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8953                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8954                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8955                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8956                 }
8957                 if (r->hardware_id) {
8958                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8959                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8960                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8961                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8962                 }
8963                 if (r->provider) {
8964                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8965                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8966                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8967                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8968                 }
8969         }
8970         return NDR_ERR_SUCCESS;
8971 }
8972
8973 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
8974 {
8975         uint32_t _ptr_driver_name;
8976         TALLOC_CTX *_mem_save_driver_name_0;
8977         uint32_t _ptr_architecture;
8978         TALLOC_CTX *_mem_save_architecture_0;
8979         uint32_t _ptr_driver_path;
8980         TALLOC_CTX *_mem_save_driver_path_0;
8981         uint32_t _ptr_data_file;
8982         TALLOC_CTX *_mem_save_data_file_0;
8983         uint32_t _ptr_config_file;
8984         TALLOC_CTX *_mem_save_config_file_0;
8985         uint32_t _ptr_help_file;
8986         TALLOC_CTX *_mem_save_help_file_0;
8987         uint32_t _ptr_monitor_name;
8988         TALLOC_CTX *_mem_save_monitor_name_0;
8989         uint32_t _ptr_default_datatype;
8990         TALLOC_CTX *_mem_save_default_datatype_0;
8991         uint32_t _ptr_dependent_files;
8992         TALLOC_CTX *_mem_save_dependent_files_0;
8993         uint32_t _ptr_previous_names;
8994         TALLOC_CTX *_mem_save_previous_names_0;
8995         uint32_t _ptr_manufacturer_name;
8996         TALLOC_CTX *_mem_save_manufacturer_name_0;
8997         uint32_t _ptr_manufacturer_url;
8998         TALLOC_CTX *_mem_save_manufacturer_url_0;
8999         uint32_t _ptr_hardware_id;
9000         TALLOC_CTX *_mem_save_hardware_id_0;
9001         uint32_t _ptr_provider;
9002         TALLOC_CTX *_mem_save_provider_0;
9003         if (ndr_flags & NDR_SCALARS) {
9004                 NDR_CHECK(ndr_pull_align(ndr, 8));
9005                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9006                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9007                 if (_ptr_driver_name) {
9008                         NDR_PULL_ALLOC(ndr, r->driver_name);
9009                 } else {
9010                         r->driver_name = NULL;
9011                 }
9012                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9013                 if (_ptr_architecture) {
9014                         NDR_PULL_ALLOC(ndr, r->architecture);
9015                 } else {
9016                         r->architecture = NULL;
9017                 }
9018                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9019                 if (_ptr_driver_path) {
9020                         NDR_PULL_ALLOC(ndr, r->driver_path);
9021                 } else {
9022                         r->driver_path = NULL;
9023                 }
9024                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9025                 if (_ptr_data_file) {
9026                         NDR_PULL_ALLOC(ndr, r->data_file);
9027                 } else {
9028                         r->data_file = NULL;
9029                 }
9030                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9031                 if (_ptr_config_file) {
9032                         NDR_PULL_ALLOC(ndr, r->config_file);
9033                 } else {
9034                         r->config_file = NULL;
9035                 }
9036                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9037                 if (_ptr_help_file) {
9038                         NDR_PULL_ALLOC(ndr, r->help_file);
9039                 } else {
9040                         r->help_file = NULL;
9041                 }
9042                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9043                 if (_ptr_monitor_name) {
9044                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9045                 } else {
9046                         r->monitor_name = NULL;
9047                 }
9048                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9049                 if (_ptr_default_datatype) {
9050                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9051                 } else {
9052                         r->default_datatype = NULL;
9053                 }
9054                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9055                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9056                 if (_ptr_dependent_files) {
9057                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9058                 } else {
9059                         r->dependent_files = NULL;
9060                 }
9061                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9062                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9063                 if (_ptr_previous_names) {
9064                         NDR_PULL_ALLOC(ndr, r->previous_names);
9065                 } else {
9066                         r->previous_names = NULL;
9067                 }
9068                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9069                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9070                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9071                 if (_ptr_manufacturer_name) {
9072                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9073                 } else {
9074                         r->manufacturer_name = NULL;
9075                 }
9076                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9077                 if (_ptr_manufacturer_url) {
9078                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9079                 } else {
9080                         r->manufacturer_url = NULL;
9081                 }
9082                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9083                 if (_ptr_hardware_id) {
9084                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9085                 } else {
9086                         r->hardware_id = NULL;
9087                 }
9088                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9089                 if (_ptr_provider) {
9090                         NDR_PULL_ALLOC(ndr, r->provider);
9091                 } else {
9092                         r->provider = NULL;
9093                 }
9094         }
9095         if (ndr_flags & NDR_BUFFERS) {
9096                 if (r->driver_name) {
9097                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9098                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9099                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9100                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9101                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9102                                 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));
9103                         }
9104                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9105                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9106                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9107                 }
9108                 if (r->architecture) {
9109                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9110                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9111                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9112                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9113                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9114                                 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));
9115                         }
9116                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9117                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9118                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9119                 }
9120                 if (r->driver_path) {
9121                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9122                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9123                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9124                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9125                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9126                                 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));
9127                         }
9128                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9129                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9130                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9131                 }
9132                 if (r->data_file) {
9133                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9134                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9135                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9136                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9137                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9138                                 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));
9139                         }
9140                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9141                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9142                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9143                 }
9144                 if (r->config_file) {
9145                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9146                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9147                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9148                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9149                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9150                                 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));
9151                         }
9152                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9153                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9154                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9155                 }
9156                 if (r->help_file) {
9157                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9158                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9159                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9160                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9161                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9162                                 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));
9163                         }
9164                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9165                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9166                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9167                 }
9168                 if (r->monitor_name) {
9169                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9170                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9171                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9172                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9173                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9174                                 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));
9175                         }
9176                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9177                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9178                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9179                 }
9180                 if (r->default_datatype) {
9181                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9182                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9183                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9184                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9185                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9186                                 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));
9187                         }
9188                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9189                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9190                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9191                 }
9192                 if (r->dependent_files) {
9193                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9194                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9195                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9196                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9197                 }
9198                 if (r->previous_names) {
9199                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9200                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9201                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9202                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9203                 }
9204                 if (r->manufacturer_name) {
9205                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9206                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9207                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9208                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9209                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9210                                 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));
9211                         }
9212                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9213                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9214                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9215                 }
9216                 if (r->manufacturer_url) {
9217                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9218                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9219                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9220                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9221                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9222                                 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));
9223                         }
9224                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9225                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9226                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9227                 }
9228                 if (r->hardware_id) {
9229                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9230                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9231                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9232                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9233                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9234                                 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));
9235                         }
9236                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9237                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9238                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9239                 }
9240                 if (r->provider) {
9241                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9242                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9243                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9244                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9245                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9246                                 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));
9247                         }
9248                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9249                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9250                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9251                 }
9252         }
9253         return NDR_ERR_SUCCESS;
9254 }
9255
9256 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
9257 {
9258         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
9259         ndr->depth++;
9260         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9261         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9262         ndr->depth++;
9263         if (r->driver_name) {
9264                 ndr_print_string(ndr, "driver_name", r->driver_name);
9265         }
9266         ndr->depth--;
9267         ndr_print_ptr(ndr, "architecture", r->architecture);
9268         ndr->depth++;
9269         if (r->architecture) {
9270                 ndr_print_string(ndr, "architecture", r->architecture);
9271         }
9272         ndr->depth--;
9273         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9274         ndr->depth++;
9275         if (r->driver_path) {
9276                 ndr_print_string(ndr, "driver_path", r->driver_path);
9277         }
9278         ndr->depth--;
9279         ndr_print_ptr(ndr, "data_file", r->data_file);
9280         ndr->depth++;
9281         if (r->data_file) {
9282                 ndr_print_string(ndr, "data_file", r->data_file);
9283         }
9284         ndr->depth--;
9285         ndr_print_ptr(ndr, "config_file", r->config_file);
9286         ndr->depth++;
9287         if (r->config_file) {
9288                 ndr_print_string(ndr, "config_file", r->config_file);
9289         }
9290         ndr->depth--;
9291         ndr_print_ptr(ndr, "help_file", r->help_file);
9292         ndr->depth++;
9293         if (r->help_file) {
9294                 ndr_print_string(ndr, "help_file", r->help_file);
9295         }
9296         ndr->depth--;
9297         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9298         ndr->depth++;
9299         if (r->monitor_name) {
9300                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9301         }
9302         ndr->depth--;
9303         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9304         ndr->depth++;
9305         if (r->default_datatype) {
9306                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9307         }
9308         ndr->depth--;
9309         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);
9310         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9311         ndr->depth++;
9312         if (r->dependent_files) {
9313                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9314         }
9315         ndr->depth--;
9316         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);
9317         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9318         ndr->depth++;
9319         if (r->previous_names) {
9320                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9321         }
9322         ndr->depth--;
9323         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9324         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9325         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9326         ndr->depth++;
9327         if (r->manufacturer_name) {
9328                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9329         }
9330         ndr->depth--;
9331         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9332         ndr->depth++;
9333         if (r->manufacturer_url) {
9334                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9335         }
9336         ndr->depth--;
9337         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9338         ndr->depth++;
9339         if (r->hardware_id) {
9340                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9341         }
9342         ndr->depth--;
9343         ndr_print_ptr(ndr, "provider", r->provider);
9344         ndr->depth++;
9345         if (r->provider) {
9346                 ndr_print_string(ndr, "provider", r->provider);
9347         }
9348         ndr->depth--;
9349         ndr->depth--;
9350 }
9351
9352 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
9353 {
9354         if (ndr_flags & NDR_SCALARS) {
9355                 NDR_CHECK(ndr_push_align(ndr, 8));
9356                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9357                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9359                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9360                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9362                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9363                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9364                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9365                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9366                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9367                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9368                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9369                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9370                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9371                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9372                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9373                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9374                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9375                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
9376                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
9377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9378                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
9379                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
9380                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9381                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9382                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
9383                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9384                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9385         }
9386         if (ndr_flags & NDR_BUFFERS) {
9387                 if (r->driver_name) {
9388                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9389                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9390                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9391                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9392                 }
9393                 if (r->architecture) {
9394                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9395                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9396                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9397                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9398                 }
9399                 if (r->driver_path) {
9400                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9401                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9402                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9403                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9404                 }
9405                 if (r->data_file) {
9406                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9407                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9408                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9409                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9410                 }
9411                 if (r->config_file) {
9412                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9415                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9416                 }
9417                 if (r->help_file) {
9418                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9419                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9420                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9421                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9422                 }
9423                 if (r->monitor_name) {
9424                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9425                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9426                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9427                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9428                 }
9429                 if (r->default_datatype) {
9430                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9433                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9434                 }
9435                 if (r->dependent_files) {
9436                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9437                 }
9438                 if (r->previous_names) {
9439                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9440                 }
9441                 if (r->manufacturer_name) {
9442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9445                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9446                 }
9447                 if (r->manufacturer_url) {
9448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9451                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9452                 }
9453                 if (r->hardware_id) {
9454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9455                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9456                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9457                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9458                 }
9459                 if (r->provider) {
9460                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9461                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9462                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9463                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9464                 }
9465                 if (r->print_processor) {
9466                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9467                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9468                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9469                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9470                 }
9471                 if (r->vendor_setup) {
9472                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9473                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9474                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9475                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9476                 }
9477                 if (r->color_profiles) {
9478                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9479                 }
9480                 if (r->inf_path) {
9481                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9482                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9483                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9484                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9485                 }
9486                 if (r->core_driver_dependencies) {
9487                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9488                 }
9489         }
9490         return NDR_ERR_SUCCESS;
9491 }
9492
9493 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
9494 {
9495         uint32_t _ptr_driver_name;
9496         TALLOC_CTX *_mem_save_driver_name_0;
9497         uint32_t _ptr_architecture;
9498         TALLOC_CTX *_mem_save_architecture_0;
9499         uint32_t _ptr_driver_path;
9500         TALLOC_CTX *_mem_save_driver_path_0;
9501         uint32_t _ptr_data_file;
9502         TALLOC_CTX *_mem_save_data_file_0;
9503         uint32_t _ptr_config_file;
9504         TALLOC_CTX *_mem_save_config_file_0;
9505         uint32_t _ptr_help_file;
9506         TALLOC_CTX *_mem_save_help_file_0;
9507         uint32_t _ptr_monitor_name;
9508         TALLOC_CTX *_mem_save_monitor_name_0;
9509         uint32_t _ptr_default_datatype;
9510         TALLOC_CTX *_mem_save_default_datatype_0;
9511         uint32_t _ptr_dependent_files;
9512         TALLOC_CTX *_mem_save_dependent_files_0;
9513         uint32_t _ptr_previous_names;
9514         TALLOC_CTX *_mem_save_previous_names_0;
9515         uint32_t _ptr_manufacturer_name;
9516         TALLOC_CTX *_mem_save_manufacturer_name_0;
9517         uint32_t _ptr_manufacturer_url;
9518         TALLOC_CTX *_mem_save_manufacturer_url_0;
9519         uint32_t _ptr_hardware_id;
9520         TALLOC_CTX *_mem_save_hardware_id_0;
9521         uint32_t _ptr_provider;
9522         TALLOC_CTX *_mem_save_provider_0;
9523         uint32_t _ptr_print_processor;
9524         TALLOC_CTX *_mem_save_print_processor_0;
9525         uint32_t _ptr_vendor_setup;
9526         TALLOC_CTX *_mem_save_vendor_setup_0;
9527         uint32_t _ptr_color_profiles;
9528         TALLOC_CTX *_mem_save_color_profiles_0;
9529         uint32_t _ptr_inf_path;
9530         TALLOC_CTX *_mem_save_inf_path_0;
9531         uint32_t _ptr_core_driver_dependencies;
9532         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9533         if (ndr_flags & NDR_SCALARS) {
9534                 NDR_CHECK(ndr_pull_align(ndr, 8));
9535                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9536                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9537                 if (_ptr_driver_name) {
9538                         NDR_PULL_ALLOC(ndr, r->driver_name);
9539                 } else {
9540                         r->driver_name = NULL;
9541                 }
9542                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9543                 if (_ptr_architecture) {
9544                         NDR_PULL_ALLOC(ndr, r->architecture);
9545                 } else {
9546                         r->architecture = NULL;
9547                 }
9548                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9549                 if (_ptr_driver_path) {
9550                         NDR_PULL_ALLOC(ndr, r->driver_path);
9551                 } else {
9552                         r->driver_path = NULL;
9553                 }
9554                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9555                 if (_ptr_data_file) {
9556                         NDR_PULL_ALLOC(ndr, r->data_file);
9557                 } else {
9558                         r->data_file = NULL;
9559                 }
9560                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9561                 if (_ptr_config_file) {
9562                         NDR_PULL_ALLOC(ndr, r->config_file);
9563                 } else {
9564                         r->config_file = NULL;
9565                 }
9566                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9567                 if (_ptr_help_file) {
9568                         NDR_PULL_ALLOC(ndr, r->help_file);
9569                 } else {
9570                         r->help_file = NULL;
9571                 }
9572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9573                 if (_ptr_monitor_name) {
9574                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9575                 } else {
9576                         r->monitor_name = NULL;
9577                 }
9578                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9579                 if (_ptr_default_datatype) {
9580                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9581                 } else {
9582                         r->default_datatype = NULL;
9583                 }
9584                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9585                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9586                 if (_ptr_dependent_files) {
9587                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9588                 } else {
9589                         r->dependent_files = NULL;
9590                 }
9591                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9592                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9593                 if (_ptr_previous_names) {
9594                         NDR_PULL_ALLOC(ndr, r->previous_names);
9595                 } else {
9596                         r->previous_names = NULL;
9597                 }
9598                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9599                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9600                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9601                 if (_ptr_manufacturer_name) {
9602                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9603                 } else {
9604                         r->manufacturer_name = NULL;
9605                 }
9606                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9607                 if (_ptr_manufacturer_url) {
9608                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9609                 } else {
9610                         r->manufacturer_url = NULL;
9611                 }
9612                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9613                 if (_ptr_hardware_id) {
9614                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9615                 } else {
9616                         r->hardware_id = NULL;
9617                 }
9618                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9619                 if (_ptr_provider) {
9620                         NDR_PULL_ALLOC(ndr, r->provider);
9621                 } else {
9622                         r->provider = NULL;
9623                 }
9624                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9625                 if (_ptr_print_processor) {
9626                         NDR_PULL_ALLOC(ndr, r->print_processor);
9627                 } else {
9628                         r->print_processor = NULL;
9629                 }
9630                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9631                 if (_ptr_vendor_setup) {
9632                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9633                 } else {
9634                         r->vendor_setup = NULL;
9635                 }
9636                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9637                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9638                 if (_ptr_color_profiles) {
9639                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9640                 } else {
9641                         r->color_profiles = NULL;
9642                 }
9643                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9644                 if (_ptr_inf_path) {
9645                         NDR_PULL_ALLOC(ndr, r->inf_path);
9646                 } else {
9647                         r->inf_path = NULL;
9648                 }
9649                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9651                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9652                 if (_ptr_core_driver_dependencies) {
9653                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9654                 } else {
9655                         r->core_driver_dependencies = NULL;
9656                 }
9657                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9658                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9659         }
9660         if (ndr_flags & NDR_BUFFERS) {
9661                 if (r->driver_name) {
9662                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9663                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9664                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9665                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9666                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9667                                 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));
9668                         }
9669                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9670                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9671                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9672                 }
9673                 if (r->architecture) {
9674                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9675                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9676                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9677                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9678                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9679                                 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));
9680                         }
9681                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9682                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9683                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9684                 }
9685                 if (r->driver_path) {
9686                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9687                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9688                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9689                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9690                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9691                                 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));
9692                         }
9693                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9694                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9695                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9696                 }
9697                 if (r->data_file) {
9698                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9699                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9700                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9701                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9702                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9703                                 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));
9704                         }
9705                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9706                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9707                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9708                 }
9709                 if (r->config_file) {
9710                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9711                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9712                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9713                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9714                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9715                                 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));
9716                         }
9717                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9718                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9719                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9720                 }
9721                 if (r->help_file) {
9722                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9723                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9724                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9725                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9726                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9727                                 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));
9728                         }
9729                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9730                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9731                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9732                 }
9733                 if (r->monitor_name) {
9734                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9735                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9736                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9737                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9738                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9739                                 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));
9740                         }
9741                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9742                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9743                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9744                 }
9745                 if (r->default_datatype) {
9746                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9747                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9748                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9749                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9750                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9751                                 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));
9752                         }
9753                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9754                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9755                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9756                 }
9757                 if (r->dependent_files) {
9758                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9759                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9760                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9761                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9762                 }
9763                 if (r->previous_names) {
9764                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9765                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9766                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9767                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9768                 }
9769                 if (r->manufacturer_name) {
9770                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9771                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9772                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9773                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9774                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9775                                 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));
9776                         }
9777                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9778                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9779                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9780                 }
9781                 if (r->manufacturer_url) {
9782                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9783                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9784                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9785                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9786                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9787                                 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));
9788                         }
9789                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9790                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9791                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9792                 }
9793                 if (r->hardware_id) {
9794                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9795                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9796                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9797                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9798                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9799                                 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));
9800                         }
9801                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9802                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9803                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9804                 }
9805                 if (r->provider) {
9806                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9807                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9808                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9809                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9810                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9811                                 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));
9812                         }
9813                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9814                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9815                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9816                 }
9817                 if (r->print_processor) {
9818                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
9819                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
9820                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
9821                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
9822                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
9823                                 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));
9824                         }
9825                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
9826                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
9827                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
9828                 }
9829                 if (r->vendor_setup) {
9830                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
9831                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
9832                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
9833                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
9834                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
9835                                 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));
9836                         }
9837                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
9838                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
9839                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
9840                 }
9841                 if (r->color_profiles) {
9842                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
9843                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
9844                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9845                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
9846                 }
9847                 if (r->inf_path) {
9848                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9849                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
9850                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
9851                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
9852                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
9853                                 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));
9854                         }
9855                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
9856                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
9857                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
9858                 }
9859                 if (r->core_driver_dependencies) {
9860                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
9861                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
9862                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9863                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
9864                 }
9865         }
9866         return NDR_ERR_SUCCESS;
9867 }
9868
9869 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
9870 {
9871         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
9872         ndr->depth++;
9873         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9874         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9875         ndr->depth++;
9876         if (r->driver_name) {
9877                 ndr_print_string(ndr, "driver_name", r->driver_name);
9878         }
9879         ndr->depth--;
9880         ndr_print_ptr(ndr, "architecture", r->architecture);
9881         ndr->depth++;
9882         if (r->architecture) {
9883                 ndr_print_string(ndr, "architecture", r->architecture);
9884         }
9885         ndr->depth--;
9886         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9887         ndr->depth++;
9888         if (r->driver_path) {
9889                 ndr_print_string(ndr, "driver_path", r->driver_path);
9890         }
9891         ndr->depth--;
9892         ndr_print_ptr(ndr, "data_file", r->data_file);
9893         ndr->depth++;
9894         if (r->data_file) {
9895                 ndr_print_string(ndr, "data_file", r->data_file);
9896         }
9897         ndr->depth--;
9898         ndr_print_ptr(ndr, "config_file", r->config_file);
9899         ndr->depth++;
9900         if (r->config_file) {
9901                 ndr_print_string(ndr, "config_file", r->config_file);
9902         }
9903         ndr->depth--;
9904         ndr_print_ptr(ndr, "help_file", r->help_file);
9905         ndr->depth++;
9906         if (r->help_file) {
9907                 ndr_print_string(ndr, "help_file", r->help_file);
9908         }
9909         ndr->depth--;
9910         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9911         ndr->depth++;
9912         if (r->monitor_name) {
9913                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9914         }
9915         ndr->depth--;
9916         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9917         ndr->depth++;
9918         if (r->default_datatype) {
9919                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9920         }
9921         ndr->depth--;
9922         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);
9923         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9924         ndr->depth++;
9925         if (r->dependent_files) {
9926                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9927         }
9928         ndr->depth--;
9929         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);
9930         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9931         ndr->depth++;
9932         if (r->previous_names) {
9933                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9934         }
9935         ndr->depth--;
9936         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9937         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9938         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9939         ndr->depth++;
9940         if (r->manufacturer_name) {
9941                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9942         }
9943         ndr->depth--;
9944         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9945         ndr->depth++;
9946         if (r->manufacturer_url) {
9947                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9948         }
9949         ndr->depth--;
9950         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9951         ndr->depth++;
9952         if (r->hardware_id) {
9953                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9954         }
9955         ndr->depth--;
9956         ndr_print_ptr(ndr, "provider", r->provider);
9957         ndr->depth++;
9958         if (r->provider) {
9959                 ndr_print_string(ndr, "provider", r->provider);
9960         }
9961         ndr->depth--;
9962         ndr_print_ptr(ndr, "print_processor", r->print_processor);
9963         ndr->depth++;
9964         if (r->print_processor) {
9965                 ndr_print_string(ndr, "print_processor", r->print_processor);
9966         }
9967         ndr->depth--;
9968         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
9969         ndr->depth++;
9970         if (r->vendor_setup) {
9971                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
9972         }
9973         ndr->depth--;
9974         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);
9975         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
9976         ndr->depth++;
9977         if (r->color_profiles) {
9978                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
9979         }
9980         ndr->depth--;
9981         ndr_print_ptr(ndr, "inf_path", r->inf_path);
9982         ndr->depth++;
9983         if (r->inf_path) {
9984                 ndr_print_string(ndr, "inf_path", r->inf_path);
9985         }
9986         ndr->depth--;
9987         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
9988         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);
9989         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9990         ndr->depth++;
9991         if (r->core_driver_dependencies) {
9992                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9993         }
9994         ndr->depth--;
9995         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
9996         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
9997         ndr->depth--;
9998 }
9999
10000 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
10001 {
10002         if (ndr_flags & NDR_SCALARS) {
10003                 int level = ndr_push_get_switch_value(ndr, r);
10004                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
10005                 switch (level) {
10006                         case 1: {
10007                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
10008                         break; }
10009
10010                         case 2: {
10011                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
10012                         break; }
10013
10014                         case 3: {
10015                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
10016                         break; }
10017
10018                         case 4: {
10019                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
10020                         break; }
10021
10022                         case 6: {
10023                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
10024                         break; }
10025
10026                         case 8: {
10027                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
10028                         break; }
10029
10030                         default:
10031                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
10032                 }
10033         }
10034         if (ndr_flags & NDR_BUFFERS) {
10035                 int level = ndr_push_get_switch_value(ndr, r);
10036                 switch (level) {
10037                         case 1:
10038                                 if (r->info1) {
10039                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10040                                 }
10041                         break;
10042
10043                         case 2:
10044                                 if (r->info2) {
10045                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10046                                 }
10047                         break;
10048
10049                         case 3:
10050                                 if (r->info3) {
10051                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10052                                 }
10053                         break;
10054
10055                         case 4:
10056                                 if (r->info4) {
10057                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10058                                 }
10059                         break;
10060
10061                         case 6:
10062                                 if (r->info6) {
10063                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10064                                 }
10065                         break;
10066
10067                         case 8:
10068                                 if (r->info8) {
10069                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10070                                 }
10071                         break;
10072
10073                         default:
10074                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
10075                 }
10076         }
10077         return NDR_ERR_SUCCESS;
10078 }
10079
10080 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
10081 {
10082         int level;
10083         uint32_t _level;
10084         TALLOC_CTX *_mem_save_info1_0;
10085         TALLOC_CTX *_mem_save_info2_0;
10086         TALLOC_CTX *_mem_save_info3_0;
10087         TALLOC_CTX *_mem_save_info4_0;
10088         TALLOC_CTX *_mem_save_info6_0;
10089         TALLOC_CTX *_mem_save_info8_0;
10090         level = ndr_pull_get_switch_value(ndr, r);
10091         if (ndr_flags & NDR_SCALARS) {
10092                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
10093                 if (_level != level) {
10094                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
10095                 }
10096                 switch (level) {
10097                         case 1: {
10098                                 uint32_t _ptr_info1;
10099                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
10100                                 if (_ptr_info1) {
10101                                         NDR_PULL_ALLOC(ndr, r->info1);
10102                                 } else {
10103                                         r->info1 = NULL;
10104                                 }
10105                         break; }
10106
10107                         case 2: {
10108                                 uint32_t _ptr_info2;
10109                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
10110                                 if (_ptr_info2) {
10111                                         NDR_PULL_ALLOC(ndr, r->info2);
10112                                 } else {
10113                                         r->info2 = NULL;
10114                                 }
10115                         break; }
10116
10117                         case 3: {
10118                                 uint32_t _ptr_info3;
10119                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
10120                                 if (_ptr_info3) {
10121                                         NDR_PULL_ALLOC(ndr, r->info3);
10122                                 } else {
10123                                         r->info3 = NULL;
10124                                 }
10125                         break; }
10126
10127                         case 4: {
10128                                 uint32_t _ptr_info4;
10129                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
10130                                 if (_ptr_info4) {
10131                                         NDR_PULL_ALLOC(ndr, r->info4);
10132                                 } else {
10133                                         r->info4 = NULL;
10134                                 }
10135                         break; }
10136
10137                         case 6: {
10138                                 uint32_t _ptr_info6;
10139                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
10140                                 if (_ptr_info6) {
10141                                         NDR_PULL_ALLOC(ndr, r->info6);
10142                                 } else {
10143                                         r->info6 = NULL;
10144                                 }
10145                         break; }
10146
10147                         case 8: {
10148                                 uint32_t _ptr_info8;
10149                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
10150                                 if (_ptr_info8) {
10151                                         NDR_PULL_ALLOC(ndr, r->info8);
10152                                 } else {
10153                                         r->info8 = NULL;
10154                                 }
10155                         break; }
10156
10157                         default:
10158                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
10159                 }
10160         }
10161         if (ndr_flags & NDR_BUFFERS) {
10162                 switch (level) {
10163                         case 1:
10164                                 if (r->info1) {
10165                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
10166                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
10167                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10168                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
10169                                 }
10170                         break;
10171
10172                         case 2:
10173                                 if (r->info2) {
10174                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
10175                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
10176                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10177                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
10178                                 }
10179                         break;
10180
10181                         case 3:
10182                                 if (r->info3) {
10183                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
10184                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
10185                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10186                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
10187                                 }
10188                         break;
10189
10190                         case 4:
10191                                 if (r->info4) {
10192                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
10193                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
10194                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10195                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
10196                                 }
10197                         break;
10198
10199                         case 6:
10200                                 if (r->info6) {
10201                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
10202                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
10203                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10204                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
10205                                 }
10206                         break;
10207
10208                         case 8:
10209                                 if (r->info8) {
10210                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
10211                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
10212                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10213                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
10214                                 }
10215                         break;
10216
10217                         default:
10218                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
10219                 }
10220         }
10221         return NDR_ERR_SUCCESS;
10222 }
10223
10224 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
10225 {
10226         int level;
10227         level = ndr_print_get_switch_value(ndr, r);
10228         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
10229         switch (level) {
10230                 case 1:
10231                         ndr_print_ptr(ndr, "info1", r->info1);
10232                         ndr->depth++;
10233                         if (r->info1) {
10234                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
10235                         }
10236                         ndr->depth--;
10237                 break;
10238
10239                 case 2:
10240                         ndr_print_ptr(ndr, "info2", r->info2);
10241                         ndr->depth++;
10242                         if (r->info2) {
10243                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
10244                         }
10245                         ndr->depth--;
10246                 break;
10247
10248                 case 3:
10249                         ndr_print_ptr(ndr, "info3", r->info3);
10250                         ndr->depth++;
10251                         if (r->info3) {
10252                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
10253                         }
10254                         ndr->depth--;
10255                 break;
10256
10257                 case 4:
10258                         ndr_print_ptr(ndr, "info4", r->info4);
10259                         ndr->depth++;
10260                         if (r->info4) {
10261                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
10262                         }
10263                         ndr->depth--;
10264                 break;
10265
10266                 case 6:
10267                         ndr_print_ptr(ndr, "info6", r->info6);
10268                         ndr->depth++;
10269                         if (r->info6) {
10270                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
10271                         }
10272                         ndr->depth--;
10273                 break;
10274
10275                 case 8:
10276                         ndr_print_ptr(ndr, "info8", r->info8);
10277                         ndr->depth++;
10278                         if (r->info8) {
10279                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
10280                         }
10281                         ndr->depth--;
10282                 break;
10283
10284                 default:
10285                         ndr_print_bad_level(ndr, name, level);
10286         }
10287 }
10288
10289 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
10290 {
10291         if (ndr_flags & NDR_SCALARS) {
10292                 NDR_CHECK(ndr_push_align(ndr, 4));
10293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
10294                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
10295                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10296         }
10297         if (ndr_flags & NDR_BUFFERS) {
10298                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10299         }
10300         return NDR_ERR_SUCCESS;
10301 }
10302
10303 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
10304 {
10305         if (ndr_flags & NDR_SCALARS) {
10306                 NDR_CHECK(ndr_pull_align(ndr, 4));
10307                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
10308                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
10309                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10310         }
10311         if (ndr_flags & NDR_BUFFERS) {
10312                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10313         }
10314         return NDR_ERR_SUCCESS;
10315 }
10316
10317 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
10318 {
10319         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
10320         ndr->depth++;
10321         ndr_print_uint32(ndr, "level", r->level);
10322         ndr_print_set_switch_value(ndr, &r->info, r->level);
10323         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
10324         ndr->depth--;
10325 }
10326
10327 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
10328 {
10329         if (ndr_flags & NDR_SCALARS) {
10330                 NDR_CHECK(ndr_push_align(ndr, 4));
10331                 {
10332                         uint32_t _flags_save_string = ndr->flags;
10333                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10334                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10335                         ndr->flags = _flags_save_string;
10336                 }
10337         }
10338         if (ndr_flags & NDR_BUFFERS) {
10339                 {
10340                         uint32_t _flags_save_string = ndr->flags;
10341                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10342                         if (r->driver_name) {
10343                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10344                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10345                         }
10346                         ndr->flags = _flags_save_string;
10347                 }
10348         }
10349         return NDR_ERR_SUCCESS;
10350 }
10351
10352 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
10353 {
10354         uint32_t _ptr_driver_name;
10355         TALLOC_CTX *_mem_save_driver_name_0;
10356         if (ndr_flags & NDR_SCALARS) {
10357                 NDR_CHECK(ndr_pull_align(ndr, 4));
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_name));
10362                         if (_ptr_driver_name) {
10363                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10364                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10365                         } else {
10366                                 r->driver_name = NULL;
10367                         }
10368                         ndr->flags = _flags_save_string;
10369                 }
10370         }
10371         if (ndr_flags & NDR_BUFFERS) {
10372                 {
10373                         uint32_t _flags_save_string = ndr->flags;
10374                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10375                         if (r->driver_name) {
10376                                 uint32_t _relative_save_offset;
10377                                 _relative_save_offset = ndr->offset;
10378                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10379                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10380                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10381                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10382                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10383                                 ndr->offset = _relative_save_offset;
10384                         }
10385                         ndr->flags = _flags_save_string;
10386                 }
10387         }
10388         return NDR_ERR_SUCCESS;
10389 }
10390
10391 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
10392 {
10393         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
10394         ndr->depth++;
10395         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10396         ndr->depth++;
10397         if (r->driver_name) {
10398                 ndr_print_string(ndr, "driver_name", r->driver_name);
10399         }
10400         ndr->depth--;
10401         ndr->depth--;
10402 }
10403
10404 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
10405 {
10406         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
10407 }
10408
10409 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
10410 {
10411         if (ndr_flags & NDR_SCALARS) {
10412                 NDR_CHECK(ndr_push_align(ndr, 4));
10413                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10414                 {
10415                         uint32_t _flags_save_string = ndr->flags;
10416                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10417                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10418                         ndr->flags = _flags_save_string;
10419                 }
10420                 {
10421                         uint32_t _flags_save_string = ndr->flags;
10422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10423                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10430                         ndr->flags = _flags_save_string;
10431                 }
10432                 {
10433                         uint32_t _flags_save_string = ndr->flags;
10434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10435                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10436                         ndr->flags = _flags_save_string;
10437                 }
10438                 {
10439                         uint32_t _flags_save_string = ndr->flags;
10440                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10441                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10442                         ndr->flags = _flags_save_string;
10443                 }
10444         }
10445         if (ndr_flags & NDR_BUFFERS) {
10446                 {
10447                         uint32_t _flags_save_string = ndr->flags;
10448                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10449                         if (r->driver_name) {
10450                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10451                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10452                         }
10453                         ndr->flags = _flags_save_string;
10454                 }
10455                 {
10456                         uint32_t _flags_save_string = ndr->flags;
10457                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10458                         if (r->architecture) {
10459                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10460                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10461                         }
10462                         ndr->flags = _flags_save_string;
10463                 }
10464                 {
10465                         uint32_t _flags_save_string = ndr->flags;
10466                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10467                         if (r->driver_path) {
10468                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10469                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10470                         }
10471                         ndr->flags = _flags_save_string;
10472                 }
10473                 {
10474                         uint32_t _flags_save_string = ndr->flags;
10475                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10476                         if (r->data_file) {
10477                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10478                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10479                         }
10480                         ndr->flags = _flags_save_string;
10481                 }
10482                 {
10483                         uint32_t _flags_save_string = ndr->flags;
10484                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10485                         if (r->config_file) {
10486                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10487                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10488                         }
10489                         ndr->flags = _flags_save_string;
10490                 }
10491         }
10492         return NDR_ERR_SUCCESS;
10493 }
10494
10495 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
10496 {
10497         uint32_t _ptr_driver_name;
10498         TALLOC_CTX *_mem_save_driver_name_0;
10499         uint32_t _ptr_architecture;
10500         TALLOC_CTX *_mem_save_architecture_0;
10501         uint32_t _ptr_driver_path;
10502         TALLOC_CTX *_mem_save_driver_path_0;
10503         uint32_t _ptr_data_file;
10504         TALLOC_CTX *_mem_save_data_file_0;
10505         uint32_t _ptr_config_file;
10506         TALLOC_CTX *_mem_save_config_file_0;
10507         if (ndr_flags & NDR_SCALARS) {
10508                 NDR_CHECK(ndr_pull_align(ndr, 4));
10509                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10510                 {
10511                         uint32_t _flags_save_string = ndr->flags;
10512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10513                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10514                         if (_ptr_driver_name) {
10515                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10516                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10517                         } else {
10518                                 r->driver_name = NULL;
10519                         }
10520                         ndr->flags = _flags_save_string;
10521                 }
10522                 {
10523                         uint32_t _flags_save_string = ndr->flags;
10524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10525                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10526                         if (_ptr_architecture) {
10527                                 NDR_PULL_ALLOC(ndr, r->architecture);
10528                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10529                         } else {
10530                                 r->architecture = NULL;
10531                         }
10532                         ndr->flags = _flags_save_string;
10533                 }
10534                 {
10535                         uint32_t _flags_save_string = ndr->flags;
10536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10537                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10538                         if (_ptr_driver_path) {
10539                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10540                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10541                         } else {
10542                                 r->driver_path = NULL;
10543                         }
10544                         ndr->flags = _flags_save_string;
10545                 }
10546                 {
10547                         uint32_t _flags_save_string = ndr->flags;
10548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10549                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10550                         if (_ptr_data_file) {
10551                                 NDR_PULL_ALLOC(ndr, r->data_file);
10552                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10553                         } else {
10554                                 r->data_file = NULL;
10555                         }
10556                         ndr->flags = _flags_save_string;
10557                 }
10558                 {
10559                         uint32_t _flags_save_string = ndr->flags;
10560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10561                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10562                         if (_ptr_config_file) {
10563                                 NDR_PULL_ALLOC(ndr, r->config_file);
10564                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10565                         } else {
10566                                 r->config_file = NULL;
10567                         }
10568                         ndr->flags = _flags_save_string;
10569                 }
10570         }
10571         if (ndr_flags & NDR_BUFFERS) {
10572                 {
10573                         uint32_t _flags_save_string = ndr->flags;
10574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10575                         if (r->driver_name) {
10576                                 uint32_t _relative_save_offset;
10577                                 _relative_save_offset = ndr->offset;
10578                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10579                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10580                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10581                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10582                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10583                                 ndr->offset = _relative_save_offset;
10584                         }
10585                         ndr->flags = _flags_save_string;
10586                 }
10587                 {
10588                         uint32_t _flags_save_string = ndr->flags;
10589                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10590                         if (r->architecture) {
10591                                 uint32_t _relative_save_offset;
10592                                 _relative_save_offset = ndr->offset;
10593                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10594                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10595                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10596                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10597                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10598                                 ndr->offset = _relative_save_offset;
10599                         }
10600                         ndr->flags = _flags_save_string;
10601                 }
10602                 {
10603                         uint32_t _flags_save_string = ndr->flags;
10604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10605                         if (r->driver_path) {
10606                                 uint32_t _relative_save_offset;
10607                                 _relative_save_offset = ndr->offset;
10608                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10609                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10610                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10611                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10612                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10613                                 ndr->offset = _relative_save_offset;
10614                         }
10615                         ndr->flags = _flags_save_string;
10616                 }
10617                 {
10618                         uint32_t _flags_save_string = ndr->flags;
10619                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10620                         if (r->data_file) {
10621                                 uint32_t _relative_save_offset;
10622                                 _relative_save_offset = ndr->offset;
10623                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10624                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10625                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10626                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10627                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10628                                 ndr->offset = _relative_save_offset;
10629                         }
10630                         ndr->flags = _flags_save_string;
10631                 }
10632                 {
10633                         uint32_t _flags_save_string = ndr->flags;
10634                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10635                         if (r->config_file) {
10636                                 uint32_t _relative_save_offset;
10637                                 _relative_save_offset = ndr->offset;
10638                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10639                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10640                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10641                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10642                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10643                                 ndr->offset = _relative_save_offset;
10644                         }
10645                         ndr->flags = _flags_save_string;
10646                 }
10647         }
10648         return NDR_ERR_SUCCESS;
10649 }
10650
10651 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10652 {
10653         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10654         ndr->depth++;
10655         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10656         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10657         ndr->depth++;
10658         if (r->driver_name) {
10659                 ndr_print_string(ndr, "driver_name", r->driver_name);
10660         }
10661         ndr->depth--;
10662         ndr_print_ptr(ndr, "architecture", r->architecture);
10663         ndr->depth++;
10664         if (r->architecture) {
10665                 ndr_print_string(ndr, "architecture", r->architecture);
10666         }
10667         ndr->depth--;
10668         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10669         ndr->depth++;
10670         if (r->driver_path) {
10671                 ndr_print_string(ndr, "driver_path", r->driver_path);
10672         }
10673         ndr->depth--;
10674         ndr_print_ptr(ndr, "data_file", r->data_file);
10675         ndr->depth++;
10676         if (r->data_file) {
10677                 ndr_print_string(ndr, "data_file", r->data_file);
10678         }
10679         ndr->depth--;
10680         ndr_print_ptr(ndr, "config_file", r->config_file);
10681         ndr->depth++;
10682         if (r->config_file) {
10683                 ndr_print_string(ndr, "config_file", r->config_file);
10684         }
10685         ndr->depth--;
10686         ndr->depth--;
10687 }
10688
10689 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10690 {
10691         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10692 }
10693
10694 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10695 {
10696         if (ndr_flags & NDR_SCALARS) {
10697                 NDR_CHECK(ndr_push_align(ndr, 4));
10698                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10699                 {
10700                         uint32_t _flags_save_string = ndr->flags;
10701                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10702                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10703                         ndr->flags = _flags_save_string;
10704                 }
10705                 {
10706                         uint32_t _flags_save_string = ndr->flags;
10707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10708                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10709                         ndr->flags = _flags_save_string;
10710                 }
10711                 {
10712                         uint32_t _flags_save_string = ndr->flags;
10713                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10714                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10715                         ndr->flags = _flags_save_string;
10716                 }
10717                 {
10718                         uint32_t _flags_save_string = ndr->flags;
10719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10720                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10721                         ndr->flags = _flags_save_string;
10722                 }
10723                 {
10724                         uint32_t _flags_save_string = ndr->flags;
10725                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10726                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10727                         ndr->flags = _flags_save_string;
10728                 }
10729                 {
10730                         uint32_t _flags_save_string = ndr->flags;
10731                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10732                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10733                         ndr->flags = _flags_save_string;
10734                 }
10735                 {
10736                         uint32_t _flags_save_string_array = ndr->flags;
10737                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10738                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10739                         ndr->flags = _flags_save_string_array;
10740                 }
10741                 {
10742                         uint32_t _flags_save_string = ndr->flags;
10743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10744                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10745                         ndr->flags = _flags_save_string;
10746                 }
10747                 {
10748                         uint32_t _flags_save_string = ndr->flags;
10749                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10750                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10751                         ndr->flags = _flags_save_string;
10752                 }
10753         }
10754         if (ndr_flags & NDR_BUFFERS) {
10755                 {
10756                         uint32_t _flags_save_string = ndr->flags;
10757                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10758                         if (r->driver_name) {
10759                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10760                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10761                         }
10762                         ndr->flags = _flags_save_string;
10763                 }
10764                 {
10765                         uint32_t _flags_save_string = ndr->flags;
10766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10767                         if (r->architecture) {
10768                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10769                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10770                         }
10771                         ndr->flags = _flags_save_string;
10772                 }
10773                 {
10774                         uint32_t _flags_save_string = ndr->flags;
10775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10776                         if (r->driver_path) {
10777                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10778                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10779                         }
10780                         ndr->flags = _flags_save_string;
10781                 }
10782                 {
10783                         uint32_t _flags_save_string = ndr->flags;
10784                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10785                         if (r->data_file) {
10786                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10787                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10788                         }
10789                         ndr->flags = _flags_save_string;
10790                 }
10791                 {
10792                         uint32_t _flags_save_string = ndr->flags;
10793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10794                         if (r->config_file) {
10795                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10796                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10797                         }
10798                         ndr->flags = _flags_save_string;
10799                 }
10800                 {
10801                         uint32_t _flags_save_string = ndr->flags;
10802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10803                         if (r->help_file) {
10804                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10805                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10806                         }
10807                         ndr->flags = _flags_save_string;
10808                 }
10809                 {
10810                         uint32_t _flags_save_string_array = ndr->flags;
10811                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10812                         if (r->dependent_files) {
10813                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10814                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10815                         }
10816                         ndr->flags = _flags_save_string_array;
10817                 }
10818                 {
10819                         uint32_t _flags_save_string = ndr->flags;
10820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10821                         if (r->monitor_name) {
10822                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10823                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10824                         }
10825                         ndr->flags = _flags_save_string;
10826                 }
10827                 {
10828                         uint32_t _flags_save_string = ndr->flags;
10829                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10830                         if (r->default_datatype) {
10831                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10832                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10833                         }
10834                         ndr->flags = _flags_save_string;
10835                 }
10836         }
10837         return NDR_ERR_SUCCESS;
10838 }
10839
10840 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
10841 {
10842         uint32_t _ptr_driver_name;
10843         TALLOC_CTX *_mem_save_driver_name_0;
10844         uint32_t _ptr_architecture;
10845         TALLOC_CTX *_mem_save_architecture_0;
10846         uint32_t _ptr_driver_path;
10847         TALLOC_CTX *_mem_save_driver_path_0;
10848         uint32_t _ptr_data_file;
10849         TALLOC_CTX *_mem_save_data_file_0;
10850         uint32_t _ptr_config_file;
10851         TALLOC_CTX *_mem_save_config_file_0;
10852         uint32_t _ptr_help_file;
10853         TALLOC_CTX *_mem_save_help_file_0;
10854         uint32_t _ptr_dependent_files;
10855         TALLOC_CTX *_mem_save_dependent_files_0;
10856         uint32_t _ptr_monitor_name;
10857         TALLOC_CTX *_mem_save_monitor_name_0;
10858         uint32_t _ptr_default_datatype;
10859         TALLOC_CTX *_mem_save_default_datatype_0;
10860         if (ndr_flags & NDR_SCALARS) {
10861                 NDR_CHECK(ndr_pull_align(ndr, 4));
10862                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10863                 {
10864                         uint32_t _flags_save_string = ndr->flags;
10865                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10866                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10867                         if (_ptr_driver_name) {
10868                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10869                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10870                         } else {
10871                                 r->driver_name = NULL;
10872                         }
10873                         ndr->flags = _flags_save_string;
10874                 }
10875                 {
10876                         uint32_t _flags_save_string = ndr->flags;
10877                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10878                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10879                         if (_ptr_architecture) {
10880                                 NDR_PULL_ALLOC(ndr, r->architecture);
10881                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10882                         } else {
10883                                 r->architecture = NULL;
10884                         }
10885                         ndr->flags = _flags_save_string;
10886                 }
10887                 {
10888                         uint32_t _flags_save_string = ndr->flags;
10889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10890                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10891                         if (_ptr_driver_path) {
10892                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10893                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10894                         } else {
10895                                 r->driver_path = NULL;
10896                         }
10897                         ndr->flags = _flags_save_string;
10898                 }
10899                 {
10900                         uint32_t _flags_save_string = ndr->flags;
10901                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10902                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10903                         if (_ptr_data_file) {
10904                                 NDR_PULL_ALLOC(ndr, r->data_file);
10905                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10906                         } else {
10907                                 r->data_file = NULL;
10908                         }
10909                         ndr->flags = _flags_save_string;
10910                 }
10911                 {
10912                         uint32_t _flags_save_string = ndr->flags;
10913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10914                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10915                         if (_ptr_config_file) {
10916                                 NDR_PULL_ALLOC(ndr, r->config_file);
10917                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10918                         } else {
10919                                 r->config_file = NULL;
10920                         }
10921                         ndr->flags = _flags_save_string;
10922                 }
10923                 {
10924                         uint32_t _flags_save_string = ndr->flags;
10925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10926                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10927                         if (_ptr_help_file) {
10928                                 NDR_PULL_ALLOC(ndr, r->help_file);
10929                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10930                         } else {
10931                                 r->help_file = NULL;
10932                         }
10933                         ndr->flags = _flags_save_string;
10934                 }
10935                 {
10936                         uint32_t _flags_save_string_array = ndr->flags;
10937                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10938                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10939                         if (_ptr_dependent_files) {
10940                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10941                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10942                         } else {
10943                                 r->dependent_files = NULL;
10944                         }
10945                         ndr->flags = _flags_save_string_array;
10946                 }
10947                 {
10948                         uint32_t _flags_save_string = ndr->flags;
10949                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10950                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10951                         if (_ptr_monitor_name) {
10952                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10953                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10954                         } else {
10955                                 r->monitor_name = NULL;
10956                         }
10957                         ndr->flags = _flags_save_string;
10958                 }
10959                 {
10960                         uint32_t _flags_save_string = ndr->flags;
10961                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10962                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10963                         if (_ptr_default_datatype) {
10964                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10965                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10966                         } else {
10967                                 r->default_datatype = NULL;
10968                         }
10969                         ndr->flags = _flags_save_string;
10970                 }
10971         }
10972         if (ndr_flags & NDR_BUFFERS) {
10973                 {
10974                         uint32_t _flags_save_string = ndr->flags;
10975                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10976                         if (r->driver_name) {
10977                                 uint32_t _relative_save_offset;
10978                                 _relative_save_offset = ndr->offset;
10979                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10980                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10981                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10982                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10983                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10984                                 ndr->offset = _relative_save_offset;
10985                         }
10986                         ndr->flags = _flags_save_string;
10987                 }
10988                 {
10989                         uint32_t _flags_save_string = ndr->flags;
10990                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10991                         if (r->architecture) {
10992                                 uint32_t _relative_save_offset;
10993                                 _relative_save_offset = ndr->offset;
10994                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10995                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10996                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10997                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10998                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10999                                 ndr->offset = _relative_save_offset;
11000                         }
11001                         ndr->flags = _flags_save_string;
11002                 }
11003                 {
11004                         uint32_t _flags_save_string = ndr->flags;
11005                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11006                         if (r->driver_path) {
11007                                 uint32_t _relative_save_offset;
11008                                 _relative_save_offset = ndr->offset;
11009                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11010                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11011                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11012                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11013                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11014                                 ndr->offset = _relative_save_offset;
11015                         }
11016                         ndr->flags = _flags_save_string;
11017                 }
11018                 {
11019                         uint32_t _flags_save_string = ndr->flags;
11020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11021                         if (r->data_file) {
11022                                 uint32_t _relative_save_offset;
11023                                 _relative_save_offset = ndr->offset;
11024                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11025                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11026                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11027                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11028                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11029                                 ndr->offset = _relative_save_offset;
11030                         }
11031                         ndr->flags = _flags_save_string;
11032                 }
11033                 {
11034                         uint32_t _flags_save_string = ndr->flags;
11035                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11036                         if (r->config_file) {
11037                                 uint32_t _relative_save_offset;
11038                                 _relative_save_offset = ndr->offset;
11039                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11040                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11041                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11042                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11043                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11044                                 ndr->offset = _relative_save_offset;
11045                         }
11046                         ndr->flags = _flags_save_string;
11047                 }
11048                 {
11049                         uint32_t _flags_save_string = ndr->flags;
11050                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11051                         if (r->help_file) {
11052                                 uint32_t _relative_save_offset;
11053                                 _relative_save_offset = ndr->offset;
11054                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11055                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11056                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11057                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11058                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11059                                 ndr->offset = _relative_save_offset;
11060                         }
11061                         ndr->flags = _flags_save_string;
11062                 }
11063                 {
11064                         uint32_t _flags_save_string_array = ndr->flags;
11065                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11066                         if (r->dependent_files) {
11067                                 uint32_t _relative_save_offset;
11068                                 _relative_save_offset = ndr->offset;
11069                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11070                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11071                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11072                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11073                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11074                                 ndr->offset = _relative_save_offset;
11075                         }
11076                         ndr->flags = _flags_save_string_array;
11077                 }
11078                 {
11079                         uint32_t _flags_save_string = ndr->flags;
11080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11081                         if (r->monitor_name) {
11082                                 uint32_t _relative_save_offset;
11083                                 _relative_save_offset = ndr->offset;
11084                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11085                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11086                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11087                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11088                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11089                                 ndr->offset = _relative_save_offset;
11090                         }
11091                         ndr->flags = _flags_save_string;
11092                 }
11093                 {
11094                         uint32_t _flags_save_string = ndr->flags;
11095                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11096                         if (r->default_datatype) {
11097                                 uint32_t _relative_save_offset;
11098                                 _relative_save_offset = ndr->offset;
11099                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11100                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11101                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11102                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11103                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11104                                 ndr->offset = _relative_save_offset;
11105                         }
11106                         ndr->flags = _flags_save_string;
11107                 }
11108         }
11109         return NDR_ERR_SUCCESS;
11110 }
11111
11112 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
11113 {
11114         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
11115         ndr->depth++;
11116         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11117         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11118         ndr->depth++;
11119         if (r->driver_name) {
11120                 ndr_print_string(ndr, "driver_name", r->driver_name);
11121         }
11122         ndr->depth--;
11123         ndr_print_ptr(ndr, "architecture", r->architecture);
11124         ndr->depth++;
11125         if (r->architecture) {
11126                 ndr_print_string(ndr, "architecture", r->architecture);
11127         }
11128         ndr->depth--;
11129         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11130         ndr->depth++;
11131         if (r->driver_path) {
11132                 ndr_print_string(ndr, "driver_path", r->driver_path);
11133         }
11134         ndr->depth--;
11135         ndr_print_ptr(ndr, "data_file", r->data_file);
11136         ndr->depth++;
11137         if (r->data_file) {
11138                 ndr_print_string(ndr, "data_file", r->data_file);
11139         }
11140         ndr->depth--;
11141         ndr_print_ptr(ndr, "config_file", r->config_file);
11142         ndr->depth++;
11143         if (r->config_file) {
11144                 ndr_print_string(ndr, "config_file", r->config_file);
11145         }
11146         ndr->depth--;
11147         ndr_print_ptr(ndr, "help_file", r->help_file);
11148         ndr->depth++;
11149         if (r->help_file) {
11150                 ndr_print_string(ndr, "help_file", r->help_file);
11151         }
11152         ndr->depth--;
11153         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11154         ndr->depth++;
11155         if (r->dependent_files) {
11156                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11157         }
11158         ndr->depth--;
11159         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11160         ndr->depth++;
11161         if (r->monitor_name) {
11162                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11163         }
11164         ndr->depth--;
11165         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11166         ndr->depth++;
11167         if (r->default_datatype) {
11168                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11169         }
11170         ndr->depth--;
11171         ndr->depth--;
11172 }
11173
11174 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
11175 {
11176         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
11177 }
11178
11179 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
11180 {
11181         if (ndr_flags & NDR_SCALARS) {
11182                 NDR_CHECK(ndr_push_align(ndr, 4));
11183                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11184                 {
11185                         uint32_t _flags_save_string = ndr->flags;
11186                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11187                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11188                         ndr->flags = _flags_save_string;
11189                 }
11190                 {
11191                         uint32_t _flags_save_string = ndr->flags;
11192                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11193                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11194                         ndr->flags = _flags_save_string;
11195                 }
11196                 {
11197                         uint32_t _flags_save_string = ndr->flags;
11198                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11199                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11200                         ndr->flags = _flags_save_string;
11201                 }
11202                 {
11203                         uint32_t _flags_save_string = ndr->flags;
11204                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11205                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11206                         ndr->flags = _flags_save_string;
11207                 }
11208                 {
11209                         uint32_t _flags_save_string = ndr->flags;
11210                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11211                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11212                         ndr->flags = _flags_save_string;
11213                 }
11214                 {
11215                         uint32_t _flags_save_string = ndr->flags;
11216                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11217                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11218                         ndr->flags = _flags_save_string;
11219                 }
11220                 {
11221                         uint32_t _flags_save_string_array = ndr->flags;
11222                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11223                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11224                         ndr->flags = _flags_save_string_array;
11225                 }
11226                 {
11227                         uint32_t _flags_save_string = ndr->flags;
11228                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11229                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
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_push_relative_ptr1(ndr, r->default_datatype));
11236                         ndr->flags = _flags_save_string;
11237                 }
11238                 {
11239                         uint32_t _flags_save_string_array = ndr->flags;
11240                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11241                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11242                         ndr->flags = _flags_save_string_array;
11243                 }
11244         }
11245         if (ndr_flags & NDR_BUFFERS) {
11246                 {
11247                         uint32_t _flags_save_string = ndr->flags;
11248                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11249                         if (r->driver_name) {
11250                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11251                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11252                         }
11253                         ndr->flags = _flags_save_string;
11254                 }
11255                 {
11256                         uint32_t _flags_save_string = ndr->flags;
11257                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11258                         if (r->architecture) {
11259                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11260                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11261                         }
11262                         ndr->flags = _flags_save_string;
11263                 }
11264                 {
11265                         uint32_t _flags_save_string = ndr->flags;
11266                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11267                         if (r->driver_path) {
11268                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11269                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11270                         }
11271                         ndr->flags = _flags_save_string;
11272                 }
11273                 {
11274                         uint32_t _flags_save_string = ndr->flags;
11275                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11276                         if (r->data_file) {
11277                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11278                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11279                         }
11280                         ndr->flags = _flags_save_string;
11281                 }
11282                 {
11283                         uint32_t _flags_save_string = ndr->flags;
11284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11285                         if (r->config_file) {
11286                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11287                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11288                         }
11289                         ndr->flags = _flags_save_string;
11290                 }
11291                 {
11292                         uint32_t _flags_save_string = ndr->flags;
11293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11294                         if (r->help_file) {
11295                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11296                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11297                         }
11298                         ndr->flags = _flags_save_string;
11299                 }
11300                 {
11301                         uint32_t _flags_save_string_array = ndr->flags;
11302                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11303                         if (r->dependent_files) {
11304                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11305                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11306                         }
11307                         ndr->flags = _flags_save_string_array;
11308                 }
11309                 {
11310                         uint32_t _flags_save_string = ndr->flags;
11311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11312                         if (r->monitor_name) {
11313                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11314                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11315                         }
11316                         ndr->flags = _flags_save_string;
11317                 }
11318                 {
11319                         uint32_t _flags_save_string = ndr->flags;
11320                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11321                         if (r->default_datatype) {
11322                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11323                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11324                         }
11325                         ndr->flags = _flags_save_string;
11326                 }
11327                 {
11328                         uint32_t _flags_save_string_array = ndr->flags;
11329                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11330                         if (r->previous_names) {
11331                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11332                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11333                         }
11334                         ndr->flags = _flags_save_string_array;
11335                 }
11336         }
11337         return NDR_ERR_SUCCESS;
11338 }
11339
11340 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
11341 {
11342         uint32_t _ptr_driver_name;
11343         TALLOC_CTX *_mem_save_driver_name_0;
11344         uint32_t _ptr_architecture;
11345         TALLOC_CTX *_mem_save_architecture_0;
11346         uint32_t _ptr_driver_path;
11347         TALLOC_CTX *_mem_save_driver_path_0;
11348         uint32_t _ptr_data_file;
11349         TALLOC_CTX *_mem_save_data_file_0;
11350         uint32_t _ptr_config_file;
11351         TALLOC_CTX *_mem_save_config_file_0;
11352         uint32_t _ptr_help_file;
11353         TALLOC_CTX *_mem_save_help_file_0;
11354         uint32_t _ptr_dependent_files;
11355         TALLOC_CTX *_mem_save_dependent_files_0;
11356         uint32_t _ptr_monitor_name;
11357         TALLOC_CTX *_mem_save_monitor_name_0;
11358         uint32_t _ptr_default_datatype;
11359         TALLOC_CTX *_mem_save_default_datatype_0;
11360         uint32_t _ptr_previous_names;
11361         TALLOC_CTX *_mem_save_previous_names_0;
11362         if (ndr_flags & NDR_SCALARS) {
11363                 NDR_CHECK(ndr_pull_align(ndr, 4));
11364                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11365                 {
11366                         uint32_t _flags_save_string = ndr->flags;
11367                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11368                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11369                         if (_ptr_driver_name) {
11370                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11371                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11372                         } else {
11373                                 r->driver_name = NULL;
11374                         }
11375                         ndr->flags = _flags_save_string;
11376                 }
11377                 {
11378                         uint32_t _flags_save_string = ndr->flags;
11379                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11380                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11381                         if (_ptr_architecture) {
11382                                 NDR_PULL_ALLOC(ndr, r->architecture);
11383                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11384                         } else {
11385                                 r->architecture = NULL;
11386                         }
11387                         ndr->flags = _flags_save_string;
11388                 }
11389                 {
11390                         uint32_t _flags_save_string = ndr->flags;
11391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11392                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11393                         if (_ptr_driver_path) {
11394                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11395                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11396                         } else {
11397                                 r->driver_path = NULL;
11398                         }
11399                         ndr->flags = _flags_save_string;
11400                 }
11401                 {
11402                         uint32_t _flags_save_string = ndr->flags;
11403                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11404                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11405                         if (_ptr_data_file) {
11406                                 NDR_PULL_ALLOC(ndr, r->data_file);
11407                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11408                         } else {
11409                                 r->data_file = NULL;
11410                         }
11411                         ndr->flags = _flags_save_string;
11412                 }
11413                 {
11414                         uint32_t _flags_save_string = ndr->flags;
11415                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11416                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11417                         if (_ptr_config_file) {
11418                                 NDR_PULL_ALLOC(ndr, r->config_file);
11419                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11420                         } else {
11421                                 r->config_file = NULL;
11422                         }
11423                         ndr->flags = _flags_save_string;
11424                 }
11425                 {
11426                         uint32_t _flags_save_string = ndr->flags;
11427                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11428                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11429                         if (_ptr_help_file) {
11430                                 NDR_PULL_ALLOC(ndr, r->help_file);
11431                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11432                         } else {
11433                                 r->help_file = NULL;
11434                         }
11435                         ndr->flags = _flags_save_string;
11436                 }
11437                 {
11438                         uint32_t _flags_save_string_array = ndr->flags;
11439                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11440                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11441                         if (_ptr_dependent_files) {
11442                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11443                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11444                         } else {
11445                                 r->dependent_files = NULL;
11446                         }
11447                         ndr->flags = _flags_save_string_array;
11448                 }
11449                 {
11450                         uint32_t _flags_save_string = ndr->flags;
11451                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11452                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11453                         if (_ptr_monitor_name) {
11454                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11455                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11456                         } else {
11457                                 r->monitor_name = NULL;
11458                         }
11459                         ndr->flags = _flags_save_string;
11460                 }
11461                 {
11462                         uint32_t _flags_save_string = ndr->flags;
11463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11464                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11465                         if (_ptr_default_datatype) {
11466                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11467                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11468                         } else {
11469                                 r->default_datatype = NULL;
11470                         }
11471                         ndr->flags = _flags_save_string;
11472                 }
11473                 {
11474                         uint32_t _flags_save_string_array = ndr->flags;
11475                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11476                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11477                         if (_ptr_previous_names) {
11478                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11479                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11480                         } else {
11481                                 r->previous_names = NULL;
11482                         }
11483                         ndr->flags = _flags_save_string_array;
11484                 }
11485         }
11486         if (ndr_flags & NDR_BUFFERS) {
11487                 {
11488                         uint32_t _flags_save_string = ndr->flags;
11489                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11490                         if (r->driver_name) {
11491                                 uint32_t _relative_save_offset;
11492                                 _relative_save_offset = ndr->offset;
11493                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11494                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11495                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11496                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11497                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11498                                 ndr->offset = _relative_save_offset;
11499                         }
11500                         ndr->flags = _flags_save_string;
11501                 }
11502                 {
11503                         uint32_t _flags_save_string = ndr->flags;
11504                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11505                         if (r->architecture) {
11506                                 uint32_t _relative_save_offset;
11507                                 _relative_save_offset = ndr->offset;
11508                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11509                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11510                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11511                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11512                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11513                                 ndr->offset = _relative_save_offset;
11514                         }
11515                         ndr->flags = _flags_save_string;
11516                 }
11517                 {
11518                         uint32_t _flags_save_string = ndr->flags;
11519                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11520                         if (r->driver_path) {
11521                                 uint32_t _relative_save_offset;
11522                                 _relative_save_offset = ndr->offset;
11523                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11524                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11525                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11526                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11527                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11528                                 ndr->offset = _relative_save_offset;
11529                         }
11530                         ndr->flags = _flags_save_string;
11531                 }
11532                 {
11533                         uint32_t _flags_save_string = ndr->flags;
11534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11535                         if (r->data_file) {
11536                                 uint32_t _relative_save_offset;
11537                                 _relative_save_offset = ndr->offset;
11538                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11539                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11540                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11541                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11542                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11543                                 ndr->offset = _relative_save_offset;
11544                         }
11545                         ndr->flags = _flags_save_string;
11546                 }
11547                 {
11548                         uint32_t _flags_save_string = ndr->flags;
11549                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11550                         if (r->config_file) {
11551                                 uint32_t _relative_save_offset;
11552                                 _relative_save_offset = ndr->offset;
11553                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11554                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11555                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11556                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11557                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11558                                 ndr->offset = _relative_save_offset;
11559                         }
11560                         ndr->flags = _flags_save_string;
11561                 }
11562                 {
11563                         uint32_t _flags_save_string = ndr->flags;
11564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11565                         if (r->help_file) {
11566                                 uint32_t _relative_save_offset;
11567                                 _relative_save_offset = ndr->offset;
11568                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11569                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11570                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11571                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11572                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11573                                 ndr->offset = _relative_save_offset;
11574                         }
11575                         ndr->flags = _flags_save_string;
11576                 }
11577                 {
11578                         uint32_t _flags_save_string_array = ndr->flags;
11579                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11580                         if (r->dependent_files) {
11581                                 uint32_t _relative_save_offset;
11582                                 _relative_save_offset = ndr->offset;
11583                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11584                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11585                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11586                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11587                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11588                                 ndr->offset = _relative_save_offset;
11589                         }
11590                         ndr->flags = _flags_save_string_array;
11591                 }
11592                 {
11593                         uint32_t _flags_save_string = ndr->flags;
11594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11595                         if (r->monitor_name) {
11596                                 uint32_t _relative_save_offset;
11597                                 _relative_save_offset = ndr->offset;
11598                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11599                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11600                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11601                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11602                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11603                                 ndr->offset = _relative_save_offset;
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->default_datatype) {
11611                                 uint32_t _relative_save_offset;
11612                                 _relative_save_offset = ndr->offset;
11613                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11614                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11615                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11616                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11617                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11618                                 ndr->offset = _relative_save_offset;
11619                         }
11620                         ndr->flags = _flags_save_string;
11621                 }
11622                 {
11623                         uint32_t _flags_save_string_array = ndr->flags;
11624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11625                         if (r->previous_names) {
11626                                 uint32_t _relative_save_offset;
11627                                 _relative_save_offset = ndr->offset;
11628                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11629                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11630                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11631                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11632                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11633                                 ndr->offset = _relative_save_offset;
11634                         }
11635                         ndr->flags = _flags_save_string_array;
11636                 }
11637         }
11638         return NDR_ERR_SUCCESS;
11639 }
11640
11641 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11642 {
11643         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11644         ndr->depth++;
11645         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11646         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11647         ndr->depth++;
11648         if (r->driver_name) {
11649                 ndr_print_string(ndr, "driver_name", r->driver_name);
11650         }
11651         ndr->depth--;
11652         ndr_print_ptr(ndr, "architecture", r->architecture);
11653         ndr->depth++;
11654         if (r->architecture) {
11655                 ndr_print_string(ndr, "architecture", r->architecture);
11656         }
11657         ndr->depth--;
11658         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11659         ndr->depth++;
11660         if (r->driver_path) {
11661                 ndr_print_string(ndr, "driver_path", r->driver_path);
11662         }
11663         ndr->depth--;
11664         ndr_print_ptr(ndr, "data_file", r->data_file);
11665         ndr->depth++;
11666         if (r->data_file) {
11667                 ndr_print_string(ndr, "data_file", r->data_file);
11668         }
11669         ndr->depth--;
11670         ndr_print_ptr(ndr, "config_file", r->config_file);
11671         ndr->depth++;
11672         if (r->config_file) {
11673                 ndr_print_string(ndr, "config_file", r->config_file);
11674         }
11675         ndr->depth--;
11676         ndr_print_ptr(ndr, "help_file", r->help_file);
11677         ndr->depth++;
11678         if (r->help_file) {
11679                 ndr_print_string(ndr, "help_file", r->help_file);
11680         }
11681         ndr->depth--;
11682         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11683         ndr->depth++;
11684         if (r->dependent_files) {
11685                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11686         }
11687         ndr->depth--;
11688         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11689         ndr->depth++;
11690         if (r->monitor_name) {
11691                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11692         }
11693         ndr->depth--;
11694         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11695         ndr->depth++;
11696         if (r->default_datatype) {
11697                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11698         }
11699         ndr->depth--;
11700         ndr_print_ptr(ndr, "previous_names", r->previous_names);
11701         ndr->depth++;
11702         if (r->previous_names) {
11703                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
11704         }
11705         ndr->depth--;
11706         ndr->depth--;
11707 }
11708
11709 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
11710 {
11711         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
11712 }
11713
11714 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
11715 {
11716         if (ndr_flags & NDR_SCALARS) {
11717                 NDR_CHECK(ndr_push_align(ndr, 4));
11718                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11719                 {
11720                         uint32_t _flags_save_string = ndr->flags;
11721                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11722                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11723                         ndr->flags = _flags_save_string;
11724                 }
11725                 {
11726                         uint32_t _flags_save_string = ndr->flags;
11727                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11728                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11729                         ndr->flags = _flags_save_string;
11730                 }
11731                 {
11732                         uint32_t _flags_save_string = ndr->flags;
11733                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11734                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11735                         ndr->flags = _flags_save_string;
11736                 }
11737                 {
11738                         uint32_t _flags_save_string = ndr->flags;
11739                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11740                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11741                         ndr->flags = _flags_save_string;
11742                 }
11743                 {
11744                         uint32_t _flags_save_string = ndr->flags;
11745                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11746                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11747                         ndr->flags = _flags_save_string;
11748                 }
11749                 NDR_CHECK(ndr_push_spoolss_DriverAttributes(ndr, NDR_SCALARS, r->driver_attributes));
11750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
11751                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
11752         }
11753         if (ndr_flags & NDR_BUFFERS) {
11754                 {
11755                         uint32_t _flags_save_string = ndr->flags;
11756                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11757                         if (r->driver_name) {
11758                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11759                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11760                         }
11761                         ndr->flags = _flags_save_string;
11762                 }
11763                 {
11764                         uint32_t _flags_save_string = ndr->flags;
11765                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11766                         if (r->architecture) {
11767                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11768                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11769                         }
11770                         ndr->flags = _flags_save_string;
11771                 }
11772                 {
11773                         uint32_t _flags_save_string = ndr->flags;
11774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11775                         if (r->driver_path) {
11776                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11777                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11778                         }
11779                         ndr->flags = _flags_save_string;
11780                 }
11781                 {
11782                         uint32_t _flags_save_string = ndr->flags;
11783                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11784                         if (r->data_file) {
11785                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11786                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11787                         }
11788                         ndr->flags = _flags_save_string;
11789                 }
11790                 {
11791                         uint32_t _flags_save_string = ndr->flags;
11792                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11793                         if (r->config_file) {
11794                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11795                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11796                         }
11797                         ndr->flags = _flags_save_string;
11798                 }
11799         }
11800         return NDR_ERR_SUCCESS;
11801 }
11802
11803 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
11804 {
11805         uint32_t _ptr_driver_name;
11806         TALLOC_CTX *_mem_save_driver_name_0;
11807         uint32_t _ptr_architecture;
11808         TALLOC_CTX *_mem_save_architecture_0;
11809         uint32_t _ptr_driver_path;
11810         TALLOC_CTX *_mem_save_driver_path_0;
11811         uint32_t _ptr_data_file;
11812         TALLOC_CTX *_mem_save_data_file_0;
11813         uint32_t _ptr_config_file;
11814         TALLOC_CTX *_mem_save_config_file_0;
11815         if (ndr_flags & NDR_SCALARS) {
11816                 NDR_CHECK(ndr_pull_align(ndr, 4));
11817                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11818                 {
11819                         uint32_t _flags_save_string = ndr->flags;
11820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11821                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11822                         if (_ptr_driver_name) {
11823                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11824                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11825                         } else {
11826                                 r->driver_name = NULL;
11827                         }
11828                         ndr->flags = _flags_save_string;
11829                 }
11830                 {
11831                         uint32_t _flags_save_string = ndr->flags;
11832                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11833                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11834                         if (_ptr_architecture) {
11835                                 NDR_PULL_ALLOC(ndr, r->architecture);
11836                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11837                         } else {
11838                                 r->architecture = NULL;
11839                         }
11840                         ndr->flags = _flags_save_string;
11841                 }
11842                 {
11843                         uint32_t _flags_save_string = ndr->flags;
11844                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11845                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11846                         if (_ptr_driver_path) {
11847                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11848                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11849                         } else {
11850                                 r->driver_path = NULL;
11851                         }
11852                         ndr->flags = _flags_save_string;
11853                 }
11854                 {
11855                         uint32_t _flags_save_string = ndr->flags;
11856                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11857                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11858                         if (_ptr_data_file) {
11859                                 NDR_PULL_ALLOC(ndr, r->data_file);
11860                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11861                         } else {
11862                                 r->data_file = NULL;
11863                         }
11864                         ndr->flags = _flags_save_string;
11865                 }
11866                 {
11867                         uint32_t _flags_save_string = ndr->flags;
11868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11869                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11870                         if (_ptr_config_file) {
11871                                 NDR_PULL_ALLOC(ndr, r->config_file);
11872                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11873                         } else {
11874                                 r->config_file = NULL;
11875                         }
11876                         ndr->flags = _flags_save_string;
11877                 }
11878                 NDR_CHECK(ndr_pull_spoolss_DriverAttributes(ndr, NDR_SCALARS, &r->driver_attributes));
11879                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
11880                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
11881         }
11882         if (ndr_flags & NDR_BUFFERS) {
11883                 {
11884                         uint32_t _flags_save_string = ndr->flags;
11885                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11886                         if (r->driver_name) {
11887                                 uint32_t _relative_save_offset;
11888                                 _relative_save_offset = ndr->offset;
11889                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11890                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11891                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11892                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11893                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11894                                 ndr->offset = _relative_save_offset;
11895                         }
11896                         ndr->flags = _flags_save_string;
11897                 }
11898                 {
11899                         uint32_t _flags_save_string = ndr->flags;
11900                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11901                         if (r->architecture) {
11902                                 uint32_t _relative_save_offset;
11903                                 _relative_save_offset = ndr->offset;
11904                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11905                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11906                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11907                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11908                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11909                                 ndr->offset = _relative_save_offset;
11910                         }
11911                         ndr->flags = _flags_save_string;
11912                 }
11913                 {
11914                         uint32_t _flags_save_string = ndr->flags;
11915                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11916                         if (r->driver_path) {
11917                                 uint32_t _relative_save_offset;
11918                                 _relative_save_offset = ndr->offset;
11919                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11920                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11921                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11922                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11923                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11924                                 ndr->offset = _relative_save_offset;
11925                         }
11926                         ndr->flags = _flags_save_string;
11927                 }
11928                 {
11929                         uint32_t _flags_save_string = ndr->flags;
11930                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11931                         if (r->data_file) {
11932                                 uint32_t _relative_save_offset;
11933                                 _relative_save_offset = ndr->offset;
11934                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11935                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11936                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11937                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11938                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11939                                 ndr->offset = _relative_save_offset;
11940                         }
11941                         ndr->flags = _flags_save_string;
11942                 }
11943                 {
11944                         uint32_t _flags_save_string = ndr->flags;
11945                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11946                         if (r->config_file) {
11947                                 uint32_t _relative_save_offset;
11948                                 _relative_save_offset = ndr->offset;
11949                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11950                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11951                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11952                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11953                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11954                                 ndr->offset = _relative_save_offset;
11955                         }
11956                         ndr->flags = _flags_save_string;
11957                 }
11958         }
11959         return NDR_ERR_SUCCESS;
11960 }
11961
11962 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
11963 {
11964         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
11965         ndr->depth++;
11966         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11967         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11968         ndr->depth++;
11969         if (r->driver_name) {
11970                 ndr_print_string(ndr, "driver_name", r->driver_name);
11971         }
11972         ndr->depth--;
11973         ndr_print_ptr(ndr, "architecture", r->architecture);
11974         ndr->depth++;
11975         if (r->architecture) {
11976                 ndr_print_string(ndr, "architecture", r->architecture);
11977         }
11978         ndr->depth--;
11979         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11980         ndr->depth++;
11981         if (r->driver_path) {
11982                 ndr_print_string(ndr, "driver_path", r->driver_path);
11983         }
11984         ndr->depth--;
11985         ndr_print_ptr(ndr, "data_file", r->data_file);
11986         ndr->depth++;
11987         if (r->data_file) {
11988                 ndr_print_string(ndr, "data_file", r->data_file);
11989         }
11990         ndr->depth--;
11991         ndr_print_ptr(ndr, "config_file", r->config_file);
11992         ndr->depth++;
11993         if (r->config_file) {
11994                 ndr_print_string(ndr, "config_file", r->config_file);
11995         }
11996         ndr->depth--;
11997         ndr_print_spoolss_DriverAttributes(ndr, "driver_attributes", r->driver_attributes);
11998         ndr_print_uint32(ndr, "config_version", r->config_version);
11999         ndr_print_uint32(ndr, "driver_version", r->driver_version);
12000         ndr->depth--;
12001 }
12002
12003 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
12004 {
12005         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
12006 }
12007
12008 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
12009 {
12010         if (ndr_flags & NDR_SCALARS) {
12011                 NDR_CHECK(ndr_push_align(ndr, 8));
12012                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12013                 {
12014                         uint32_t _flags_save_string = ndr->flags;
12015                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12016                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12017                         ndr->flags = _flags_save_string;
12018                 }
12019                 {
12020                         uint32_t _flags_save_string = ndr->flags;
12021                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12022                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12023                         ndr->flags = _flags_save_string;
12024                 }
12025                 {
12026                         uint32_t _flags_save_string = ndr->flags;
12027                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12028                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12029                         ndr->flags = _flags_save_string;
12030                 }
12031                 {
12032                         uint32_t _flags_save_string = ndr->flags;
12033                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12034                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12035                         ndr->flags = _flags_save_string;
12036                 }
12037                 {
12038                         uint32_t _flags_save_string = ndr->flags;
12039                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12040                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12041                         ndr->flags = _flags_save_string;
12042                 }
12043                 {
12044                         uint32_t _flags_save_string = ndr->flags;
12045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12046                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12047                         ndr->flags = _flags_save_string;
12048                 }
12049                 {
12050                         uint32_t _flags_save_string_array = ndr->flags;
12051                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12052                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12053                         ndr->flags = _flags_save_string_array;
12054                 }
12055                 {
12056                         uint32_t _flags_save_string = ndr->flags;
12057                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12058                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12059                         ndr->flags = _flags_save_string;
12060                 }
12061                 {
12062                         uint32_t _flags_save_string = ndr->flags;
12063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12064                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12065                         ndr->flags = _flags_save_string;
12066                 }
12067                 {
12068                         uint32_t _flags_save_string_array = ndr->flags;
12069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12070                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12071                         ndr->flags = _flags_save_string_array;
12072                 }
12073                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12074                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12075                 {
12076                         uint32_t _flags_save_string = ndr->flags;
12077                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12078                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12079                         ndr->flags = _flags_save_string;
12080                 }
12081                 {
12082                         uint32_t _flags_save_string = ndr->flags;
12083                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12084                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12085                         ndr->flags = _flags_save_string;
12086                 }
12087                 {
12088                         uint32_t _flags_save_string = ndr->flags;
12089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12090                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12091                         ndr->flags = _flags_save_string;
12092                 }
12093                 {
12094                         uint32_t _flags_save_string = ndr->flags;
12095                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12096                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12097                         ndr->flags = _flags_save_string;
12098                 }
12099         }
12100         if (ndr_flags & NDR_BUFFERS) {
12101                 {
12102                         uint32_t _flags_save_string = ndr->flags;
12103                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12104                         if (r->driver_name) {
12105                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12106                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12107                         }
12108                         ndr->flags = _flags_save_string;
12109                 }
12110                 {
12111                         uint32_t _flags_save_string = ndr->flags;
12112                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12113                         if (r->architecture) {
12114                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12115                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12116                         }
12117                         ndr->flags = _flags_save_string;
12118                 }
12119                 {
12120                         uint32_t _flags_save_string = ndr->flags;
12121                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12122                         if (r->driver_path) {
12123                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12124                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12125                         }
12126                         ndr->flags = _flags_save_string;
12127                 }
12128                 {
12129                         uint32_t _flags_save_string = ndr->flags;
12130                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12131                         if (r->data_file) {
12132                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12133                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12134                         }
12135                         ndr->flags = _flags_save_string;
12136                 }
12137                 {
12138                         uint32_t _flags_save_string = ndr->flags;
12139                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12140                         if (r->config_file) {
12141                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12142                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12143                         }
12144                         ndr->flags = _flags_save_string;
12145                 }
12146                 {
12147                         uint32_t _flags_save_string = ndr->flags;
12148                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12149                         if (r->help_file) {
12150                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12151                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12152                         }
12153                         ndr->flags = _flags_save_string;
12154                 }
12155                 {
12156                         uint32_t _flags_save_string_array = ndr->flags;
12157                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12158                         if (r->dependent_files) {
12159                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12160                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12161                         }
12162                         ndr->flags = _flags_save_string_array;
12163                 }
12164                 {
12165                         uint32_t _flags_save_string = ndr->flags;
12166                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12167                         if (r->monitor_name) {
12168                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12169                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12170                         }
12171                         ndr->flags = _flags_save_string;
12172                 }
12173                 {
12174                         uint32_t _flags_save_string = ndr->flags;
12175                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12176                         if (r->default_datatype) {
12177                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12178                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12179                         }
12180                         ndr->flags = _flags_save_string;
12181                 }
12182                 {
12183                         uint32_t _flags_save_string_array = ndr->flags;
12184                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12185                         if (r->previous_names) {
12186                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12187                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12188                         }
12189                         ndr->flags = _flags_save_string_array;
12190                 }
12191                 {
12192                         uint32_t _flags_save_string = ndr->flags;
12193                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12194                         if (r->manufacturer_name) {
12195                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12196                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12197                         }
12198                         ndr->flags = _flags_save_string;
12199                 }
12200                 {
12201                         uint32_t _flags_save_string = ndr->flags;
12202                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12203                         if (r->manufacturer_url) {
12204                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12205                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12206                         }
12207                         ndr->flags = _flags_save_string;
12208                 }
12209                 {
12210                         uint32_t _flags_save_string = ndr->flags;
12211                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12212                         if (r->hardware_id) {
12213                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12214                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12215                         }
12216                         ndr->flags = _flags_save_string;
12217                 }
12218                 {
12219                         uint32_t _flags_save_string = ndr->flags;
12220                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12221                         if (r->provider) {
12222                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12223                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12224                         }
12225                         ndr->flags = _flags_save_string;
12226                 }
12227         }
12228         return NDR_ERR_SUCCESS;
12229 }
12230
12231 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
12232 {
12233         uint32_t _ptr_driver_name;
12234         TALLOC_CTX *_mem_save_driver_name_0;
12235         uint32_t _ptr_architecture;
12236         TALLOC_CTX *_mem_save_architecture_0;
12237         uint32_t _ptr_driver_path;
12238         TALLOC_CTX *_mem_save_driver_path_0;
12239         uint32_t _ptr_data_file;
12240         TALLOC_CTX *_mem_save_data_file_0;
12241         uint32_t _ptr_config_file;
12242         TALLOC_CTX *_mem_save_config_file_0;
12243         uint32_t _ptr_help_file;
12244         TALLOC_CTX *_mem_save_help_file_0;
12245         uint32_t _ptr_dependent_files;
12246         TALLOC_CTX *_mem_save_dependent_files_0;
12247         uint32_t _ptr_monitor_name;
12248         TALLOC_CTX *_mem_save_monitor_name_0;
12249         uint32_t _ptr_default_datatype;
12250         TALLOC_CTX *_mem_save_default_datatype_0;
12251         uint32_t _ptr_previous_names;
12252         TALLOC_CTX *_mem_save_previous_names_0;
12253         uint32_t _ptr_manufacturer_name;
12254         TALLOC_CTX *_mem_save_manufacturer_name_0;
12255         uint32_t _ptr_manufacturer_url;
12256         TALLOC_CTX *_mem_save_manufacturer_url_0;
12257         uint32_t _ptr_hardware_id;
12258         TALLOC_CTX *_mem_save_hardware_id_0;
12259         uint32_t _ptr_provider;
12260         TALLOC_CTX *_mem_save_provider_0;
12261         if (ndr_flags & NDR_SCALARS) {
12262                 NDR_CHECK(ndr_pull_align(ndr, 8));
12263                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12264                 {
12265                         uint32_t _flags_save_string = ndr->flags;
12266                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12267                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12268                         if (_ptr_driver_name) {
12269                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12270                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12271                         } else {
12272                                 r->driver_name = NULL;
12273                         }
12274                         ndr->flags = _flags_save_string;
12275                 }
12276                 {
12277                         uint32_t _flags_save_string = ndr->flags;
12278                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12279                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12280                         if (_ptr_architecture) {
12281                                 NDR_PULL_ALLOC(ndr, r->architecture);
12282                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12283                         } else {
12284                                 r->architecture = NULL;
12285                         }
12286                         ndr->flags = _flags_save_string;
12287                 }
12288                 {
12289                         uint32_t _flags_save_string = ndr->flags;
12290                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12291                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12292                         if (_ptr_driver_path) {
12293                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12294                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12295                         } else {
12296                                 r->driver_path = NULL;
12297                         }
12298                         ndr->flags = _flags_save_string;
12299                 }
12300                 {
12301                         uint32_t _flags_save_string = ndr->flags;
12302                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12303                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12304                         if (_ptr_data_file) {
12305                                 NDR_PULL_ALLOC(ndr, r->data_file);
12306                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12307                         } else {
12308                                 r->data_file = NULL;
12309                         }
12310                         ndr->flags = _flags_save_string;
12311                 }
12312                 {
12313                         uint32_t _flags_save_string = ndr->flags;
12314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12315                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12316                         if (_ptr_config_file) {
12317                                 NDR_PULL_ALLOC(ndr, r->config_file);
12318                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12319                         } else {
12320                                 r->config_file = NULL;
12321                         }
12322                         ndr->flags = _flags_save_string;
12323                 }
12324                 {
12325                         uint32_t _flags_save_string = ndr->flags;
12326                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12327                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12328                         if (_ptr_help_file) {
12329                                 NDR_PULL_ALLOC(ndr, r->help_file);
12330                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12331                         } else {
12332                                 r->help_file = NULL;
12333                         }
12334                         ndr->flags = _flags_save_string;
12335                 }
12336                 {
12337                         uint32_t _flags_save_string_array = ndr->flags;
12338                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12339                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12340                         if (_ptr_dependent_files) {
12341                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12342                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12343                         } else {
12344                                 r->dependent_files = NULL;
12345                         }
12346                         ndr->flags = _flags_save_string_array;
12347                 }
12348                 {
12349                         uint32_t _flags_save_string = ndr->flags;
12350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12351                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12352                         if (_ptr_monitor_name) {
12353                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12354                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12355                         } else {
12356                                 r->monitor_name = NULL;
12357                         }
12358                         ndr->flags = _flags_save_string;
12359                 }
12360                 {
12361                         uint32_t _flags_save_string = ndr->flags;
12362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12363                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12364                         if (_ptr_default_datatype) {
12365                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12366                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12367                         } else {
12368                                 r->default_datatype = NULL;
12369                         }
12370                         ndr->flags = _flags_save_string;
12371                 }
12372                 {
12373                         uint32_t _flags_save_string_array = ndr->flags;
12374                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12375                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12376                         if (_ptr_previous_names) {
12377                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12378                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12379                         } else {
12380                                 r->previous_names = NULL;
12381                         }
12382                         ndr->flags = _flags_save_string_array;
12383                 }
12384                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12385                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12386                 {
12387                         uint32_t _flags_save_string = ndr->flags;
12388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12389                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12390                         if (_ptr_manufacturer_name) {
12391                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12392                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12393                         } else {
12394                                 r->manufacturer_name = NULL;
12395                         }
12396                         ndr->flags = _flags_save_string;
12397                 }
12398                 {
12399                         uint32_t _flags_save_string = ndr->flags;
12400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12401                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12402                         if (_ptr_manufacturer_url) {
12403                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12404                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12405                         } else {
12406                                 r->manufacturer_url = NULL;
12407                         }
12408                         ndr->flags = _flags_save_string;
12409                 }
12410                 {
12411                         uint32_t _flags_save_string = ndr->flags;
12412                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12413                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12414                         if (_ptr_hardware_id) {
12415                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12416                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12417                         } else {
12418                                 r->hardware_id = NULL;
12419                         }
12420                         ndr->flags = _flags_save_string;
12421                 }
12422                 {
12423                         uint32_t _flags_save_string = ndr->flags;
12424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12425                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12426                         if (_ptr_provider) {
12427                                 NDR_PULL_ALLOC(ndr, r->provider);
12428                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12429                         } else {
12430                                 r->provider = NULL;
12431                         }
12432                         ndr->flags = _flags_save_string;
12433                 }
12434         }
12435         if (ndr_flags & NDR_BUFFERS) {
12436                 {
12437                         uint32_t _flags_save_string = ndr->flags;
12438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12439                         if (r->driver_name) {
12440                                 uint32_t _relative_save_offset;
12441                                 _relative_save_offset = ndr->offset;
12442                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12443                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12444                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12445                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12446                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12447                                 ndr->offset = _relative_save_offset;
12448                         }
12449                         ndr->flags = _flags_save_string;
12450                 }
12451                 {
12452                         uint32_t _flags_save_string = ndr->flags;
12453                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12454                         if (r->architecture) {
12455                                 uint32_t _relative_save_offset;
12456                                 _relative_save_offset = ndr->offset;
12457                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12458                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12459                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12460                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12461                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12462                                 ndr->offset = _relative_save_offset;
12463                         }
12464                         ndr->flags = _flags_save_string;
12465                 }
12466                 {
12467                         uint32_t _flags_save_string = ndr->flags;
12468                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12469                         if (r->driver_path) {
12470                                 uint32_t _relative_save_offset;
12471                                 _relative_save_offset = ndr->offset;
12472                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12473                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12474                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12475                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12476                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12477                                 ndr->offset = _relative_save_offset;
12478                         }
12479                         ndr->flags = _flags_save_string;
12480                 }
12481                 {
12482                         uint32_t _flags_save_string = ndr->flags;
12483                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12484                         if (r->data_file) {
12485                                 uint32_t _relative_save_offset;
12486                                 _relative_save_offset = ndr->offset;
12487                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12488                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12489                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12490                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12491                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12492                                 ndr->offset = _relative_save_offset;
12493                         }
12494                         ndr->flags = _flags_save_string;
12495                 }
12496                 {
12497                         uint32_t _flags_save_string = ndr->flags;
12498                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12499                         if (r->config_file) {
12500                                 uint32_t _relative_save_offset;
12501                                 _relative_save_offset = ndr->offset;
12502                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12503                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12504                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12505                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12506                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12507                                 ndr->offset = _relative_save_offset;
12508                         }
12509                         ndr->flags = _flags_save_string;
12510                 }
12511                 {
12512                         uint32_t _flags_save_string = ndr->flags;
12513                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12514                         if (r->help_file) {
12515                                 uint32_t _relative_save_offset;
12516                                 _relative_save_offset = ndr->offset;
12517                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12518                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12519                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12520                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12521                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12522                                 ndr->offset = _relative_save_offset;
12523                         }
12524                         ndr->flags = _flags_save_string;
12525                 }
12526                 {
12527                         uint32_t _flags_save_string_array = ndr->flags;
12528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12529                         if (r->dependent_files) {
12530                                 uint32_t _relative_save_offset;
12531                                 _relative_save_offset = ndr->offset;
12532                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12533                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12534                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12535                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12536                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12537                                 ndr->offset = _relative_save_offset;
12538                         }
12539                         ndr->flags = _flags_save_string_array;
12540                 }
12541                 {
12542                         uint32_t _flags_save_string = ndr->flags;
12543                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12544                         if (r->monitor_name) {
12545                                 uint32_t _relative_save_offset;
12546                                 _relative_save_offset = ndr->offset;
12547                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12548                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12549                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12550                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12551                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12552                                 ndr->offset = _relative_save_offset;
12553                         }
12554                         ndr->flags = _flags_save_string;
12555                 }
12556                 {
12557                         uint32_t _flags_save_string = ndr->flags;
12558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12559                         if (r->default_datatype) {
12560                                 uint32_t _relative_save_offset;
12561                                 _relative_save_offset = ndr->offset;
12562                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12563                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12564                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12565                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12566                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12567                                 ndr->offset = _relative_save_offset;
12568                         }
12569                         ndr->flags = _flags_save_string;
12570                 }
12571                 {
12572                         uint32_t _flags_save_string_array = ndr->flags;
12573                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12574                         if (r->previous_names) {
12575                                 uint32_t _relative_save_offset;
12576                                 _relative_save_offset = ndr->offset;
12577                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12578                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12579                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12580                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12581                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12582                                 ndr->offset = _relative_save_offset;
12583                         }
12584                         ndr->flags = _flags_save_string_array;
12585                 }
12586                 {
12587                         uint32_t _flags_save_string = ndr->flags;
12588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12589                         if (r->manufacturer_name) {
12590                                 uint32_t _relative_save_offset;
12591                                 _relative_save_offset = ndr->offset;
12592                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12593                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12594                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12595                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12596                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12597                                 ndr->offset = _relative_save_offset;
12598                         }
12599                         ndr->flags = _flags_save_string;
12600                 }
12601                 {
12602                         uint32_t _flags_save_string = ndr->flags;
12603                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12604                         if (r->manufacturer_url) {
12605                                 uint32_t _relative_save_offset;
12606                                 _relative_save_offset = ndr->offset;
12607                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12608                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12609                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12610                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12611                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12612                                 ndr->offset = _relative_save_offset;
12613                         }
12614                         ndr->flags = _flags_save_string;
12615                 }
12616                 {
12617                         uint32_t _flags_save_string = ndr->flags;
12618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12619                         if (r->hardware_id) {
12620                                 uint32_t _relative_save_offset;
12621                                 _relative_save_offset = ndr->offset;
12622                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12623                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12624                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12625                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12626                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12627                                 ndr->offset = _relative_save_offset;
12628                         }
12629                         ndr->flags = _flags_save_string;
12630                 }
12631                 {
12632                         uint32_t _flags_save_string = ndr->flags;
12633                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12634                         if (r->provider) {
12635                                 uint32_t _relative_save_offset;
12636                                 _relative_save_offset = ndr->offset;
12637                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12638                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12639                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12640                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12641                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12642                                 ndr->offset = _relative_save_offset;
12643                         }
12644                         ndr->flags = _flags_save_string;
12645                 }
12646         }
12647         return NDR_ERR_SUCCESS;
12648 }
12649
12650 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
12651 {
12652         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
12653         ndr->depth++;
12654         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12655         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12656         ndr->depth++;
12657         if (r->driver_name) {
12658                 ndr_print_string(ndr, "driver_name", r->driver_name);
12659         }
12660         ndr->depth--;
12661         ndr_print_ptr(ndr, "architecture", r->architecture);
12662         ndr->depth++;
12663         if (r->architecture) {
12664                 ndr_print_string(ndr, "architecture", r->architecture);
12665         }
12666         ndr->depth--;
12667         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12668         ndr->depth++;
12669         if (r->driver_path) {
12670                 ndr_print_string(ndr, "driver_path", r->driver_path);
12671         }
12672         ndr->depth--;
12673         ndr_print_ptr(ndr, "data_file", r->data_file);
12674         ndr->depth++;
12675         if (r->data_file) {
12676                 ndr_print_string(ndr, "data_file", r->data_file);
12677         }
12678         ndr->depth--;
12679         ndr_print_ptr(ndr, "config_file", r->config_file);
12680         ndr->depth++;
12681         if (r->config_file) {
12682                 ndr_print_string(ndr, "config_file", r->config_file);
12683         }
12684         ndr->depth--;
12685         ndr_print_ptr(ndr, "help_file", r->help_file);
12686         ndr->depth++;
12687         if (r->help_file) {
12688                 ndr_print_string(ndr, "help_file", r->help_file);
12689         }
12690         ndr->depth--;
12691         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12692         ndr->depth++;
12693         if (r->dependent_files) {
12694                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12695         }
12696         ndr->depth--;
12697         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12698         ndr->depth++;
12699         if (r->monitor_name) {
12700                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12701         }
12702         ndr->depth--;
12703         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12704         ndr->depth++;
12705         if (r->default_datatype) {
12706                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12707         }
12708         ndr->depth--;
12709         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12710         ndr->depth++;
12711         if (r->previous_names) {
12712                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12713         }
12714         ndr->depth--;
12715         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
12716         ndr_print_hyper(ndr, "driver_version", r->driver_version);
12717         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
12718         ndr->depth++;
12719         if (r->manufacturer_name) {
12720                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
12721         }
12722         ndr->depth--;
12723         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
12724         ndr->depth++;
12725         if (r->manufacturer_url) {
12726                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
12727         }
12728         ndr->depth--;
12729         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
12730         ndr->depth++;
12731         if (r->hardware_id) {
12732                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
12733         }
12734         ndr->depth--;
12735         ndr_print_ptr(ndr, "provider", r->provider);
12736         ndr->depth++;
12737         if (r->provider) {
12738                 ndr_print_string(ndr, "provider", r->provider);
12739         }
12740         ndr->depth--;
12741         ndr->depth--;
12742 }
12743
12744 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
12745 {
12746         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
12747 }
12748
12749 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
12750 {
12751         if (ndr_flags & NDR_SCALARS) {
12752                 NDR_CHECK(ndr_push_align(ndr, 8));
12753                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12754                 {
12755                         uint32_t _flags_save_string = ndr->flags;
12756                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12757                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12758                         ndr->flags = _flags_save_string;
12759                 }
12760                 {
12761                         uint32_t _flags_save_string = ndr->flags;
12762                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12763                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12764                         ndr->flags = _flags_save_string;
12765                 }
12766                 {
12767                         uint32_t _flags_save_string = ndr->flags;
12768                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12769                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12770                         ndr->flags = _flags_save_string;
12771                 }
12772                 {
12773                         uint32_t _flags_save_string = ndr->flags;
12774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12775                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12776                         ndr->flags = _flags_save_string;
12777                 }
12778                 {
12779                         uint32_t _flags_save_string = ndr->flags;
12780                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12781                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12782                         ndr->flags = _flags_save_string;
12783                 }
12784                 {
12785                         uint32_t _flags_save_string = ndr->flags;
12786                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12787                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12788                         ndr->flags = _flags_save_string;
12789                 }
12790                 {
12791                         uint32_t _flags_save_string = ndr->flags;
12792                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12793                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12794                         ndr->flags = _flags_save_string;
12795                 }
12796                 {
12797                         uint32_t _flags_save_string = ndr->flags;
12798                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12799                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12800                         ndr->flags = _flags_save_string;
12801                 }
12802                 {
12803                         uint32_t _flags_save_string_array = ndr->flags;
12804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12805                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12806                         ndr->flags = _flags_save_string_array;
12807                 }
12808                 {
12809                         uint32_t _flags_save_string_array = ndr->flags;
12810                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12811                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12812                         ndr->flags = _flags_save_string_array;
12813                 }
12814                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12815                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12816                 {
12817                         uint32_t _flags_save_string = ndr->flags;
12818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12819                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12820                         ndr->flags = _flags_save_string;
12821                 }
12822                 {
12823                         uint32_t _flags_save_string = ndr->flags;
12824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12825                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12826                         ndr->flags = _flags_save_string;
12827                 }
12828                 {
12829                         uint32_t _flags_save_string = ndr->flags;
12830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12831                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12832                         ndr->flags = _flags_save_string;
12833                 }
12834                 {
12835                         uint32_t _flags_save_string = ndr->flags;
12836                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12837                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12838                         ndr->flags = _flags_save_string;
12839                 }
12840                 {
12841                         uint32_t _flags_save_string = ndr->flags;
12842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12843                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
12844                         ndr->flags = _flags_save_string;
12845                 }
12846                 {
12847                         uint32_t _flags_save_string = ndr->flags;
12848                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12849                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
12850                         ndr->flags = _flags_save_string;
12851                 }
12852                 {
12853                         uint32_t _flags_save_string_array = ndr->flags;
12854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12855                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
12856                         ndr->flags = _flags_save_string_array;
12857                 }
12858                 {
12859                         uint32_t _flags_save_string = ndr->flags;
12860                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12861                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
12862                         ndr->flags = _flags_save_string;
12863                 }
12864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
12865                 {
12866                         uint32_t _flags_save_string_array = ndr->flags;
12867                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12868                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
12869                         ndr->flags = _flags_save_string_array;
12870                 }
12871                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
12872                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
12873         }
12874         if (ndr_flags & NDR_BUFFERS) {
12875                 {
12876                         uint32_t _flags_save_string = ndr->flags;
12877                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12878                         if (r->driver_name) {
12879                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12880                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12881                         }
12882                         ndr->flags = _flags_save_string;
12883                 }
12884                 {
12885                         uint32_t _flags_save_string = ndr->flags;
12886                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12887                         if (r->architecture) {
12888                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12889                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12890                         }
12891                         ndr->flags = _flags_save_string;
12892                 }
12893                 {
12894                         uint32_t _flags_save_string = ndr->flags;
12895                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12896                         if (r->driver_path) {
12897                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12898                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12899                         }
12900                         ndr->flags = _flags_save_string;
12901                 }
12902                 {
12903                         uint32_t _flags_save_string = ndr->flags;
12904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12905                         if (r->data_file) {
12906                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12907                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12908                         }
12909                         ndr->flags = _flags_save_string;
12910                 }
12911                 {
12912                         uint32_t _flags_save_string = ndr->flags;
12913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12914                         if (r->config_file) {
12915                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12916                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12917                         }
12918                         ndr->flags = _flags_save_string;
12919                 }
12920                 {
12921                         uint32_t _flags_save_string = ndr->flags;
12922                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12923                         if (r->help_file) {
12924                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12925                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12926                         }
12927                         ndr->flags = _flags_save_string;
12928                 }
12929                 {
12930                         uint32_t _flags_save_string = ndr->flags;
12931                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12932                         if (r->monitor_name) {
12933                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12934                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12935                         }
12936                         ndr->flags = _flags_save_string;
12937                 }
12938                 {
12939                         uint32_t _flags_save_string = ndr->flags;
12940                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12941                         if (r->default_datatype) {
12942                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12943                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12944                         }
12945                         ndr->flags = _flags_save_string;
12946                 }
12947                 {
12948                         uint32_t _flags_save_string_array = ndr->flags;
12949                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12950                         if (r->dependent_files) {
12951                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12952                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12953                         }
12954                         ndr->flags = _flags_save_string_array;
12955                 }
12956                 {
12957                         uint32_t _flags_save_string_array = ndr->flags;
12958                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12959                         if (r->previous_names) {
12960                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12961                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12962                         }
12963                         ndr->flags = _flags_save_string_array;
12964                 }
12965                 {
12966                         uint32_t _flags_save_string = ndr->flags;
12967                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12968                         if (r->manufacturer_name) {
12969                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12970                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12971                         }
12972                         ndr->flags = _flags_save_string;
12973                 }
12974                 {
12975                         uint32_t _flags_save_string = ndr->flags;
12976                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12977                         if (r->manufacturer_url) {
12978                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12979                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12980                         }
12981                         ndr->flags = _flags_save_string;
12982                 }
12983                 {
12984                         uint32_t _flags_save_string = ndr->flags;
12985                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12986                         if (r->hardware_id) {
12987                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12988                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12989                         }
12990                         ndr->flags = _flags_save_string;
12991                 }
12992                 {
12993                         uint32_t _flags_save_string = ndr->flags;
12994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12995                         if (r->provider) {
12996                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12997                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12998                         }
12999                         ndr->flags = _flags_save_string;
13000                 }
13001                 {
13002                         uint32_t _flags_save_string = ndr->flags;
13003                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13004                         if (r->print_processor) {
13005                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
13006                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
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                         if (r->vendor_setup) {
13014                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
13015                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
13016                         }
13017                         ndr->flags = _flags_save_string;
13018                 }
13019                 {
13020                         uint32_t _flags_save_string_array = ndr->flags;
13021                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13022                         if (r->color_profiles) {
13023                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
13024                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
13025                         }
13026                         ndr->flags = _flags_save_string_array;
13027                 }
13028                 {
13029                         uint32_t _flags_save_string = ndr->flags;
13030                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13031                         if (r->inf_path) {
13032                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
13033                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
13034                         }
13035                         ndr->flags = _flags_save_string;
13036                 }
13037                 {
13038                         uint32_t _flags_save_string_array = ndr->flags;
13039                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13040                         if (r->core_driver_dependencies) {
13041                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
13042                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
13043                         }
13044                         ndr->flags = _flags_save_string_array;
13045                 }
13046         }
13047         return NDR_ERR_SUCCESS;
13048 }
13049
13050 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
13051 {
13052         uint32_t _ptr_driver_name;
13053         TALLOC_CTX *_mem_save_driver_name_0;
13054         uint32_t _ptr_architecture;
13055         TALLOC_CTX *_mem_save_architecture_0;
13056         uint32_t _ptr_driver_path;
13057         TALLOC_CTX *_mem_save_driver_path_0;
13058         uint32_t _ptr_data_file;
13059         TALLOC_CTX *_mem_save_data_file_0;
13060         uint32_t _ptr_config_file;
13061         TALLOC_CTX *_mem_save_config_file_0;
13062         uint32_t _ptr_help_file;
13063         TALLOC_CTX *_mem_save_help_file_0;
13064         uint32_t _ptr_monitor_name;
13065         TALLOC_CTX *_mem_save_monitor_name_0;
13066         uint32_t _ptr_default_datatype;
13067         TALLOC_CTX *_mem_save_default_datatype_0;
13068         uint32_t _ptr_dependent_files;
13069         TALLOC_CTX *_mem_save_dependent_files_0;
13070         uint32_t _ptr_previous_names;
13071         TALLOC_CTX *_mem_save_previous_names_0;
13072         uint32_t _ptr_manufacturer_name;
13073         TALLOC_CTX *_mem_save_manufacturer_name_0;
13074         uint32_t _ptr_manufacturer_url;
13075         TALLOC_CTX *_mem_save_manufacturer_url_0;
13076         uint32_t _ptr_hardware_id;
13077         TALLOC_CTX *_mem_save_hardware_id_0;
13078         uint32_t _ptr_provider;
13079         TALLOC_CTX *_mem_save_provider_0;
13080         uint32_t _ptr_print_processor;
13081         TALLOC_CTX *_mem_save_print_processor_0;
13082         uint32_t _ptr_vendor_setup;
13083         TALLOC_CTX *_mem_save_vendor_setup_0;
13084         uint32_t _ptr_color_profiles;
13085         TALLOC_CTX *_mem_save_color_profiles_0;
13086         uint32_t _ptr_inf_path;
13087         TALLOC_CTX *_mem_save_inf_path_0;
13088         uint32_t _ptr_core_driver_dependencies;
13089         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
13090         if (ndr_flags & NDR_SCALARS) {
13091                 NDR_CHECK(ndr_pull_align(ndr, 8));
13092                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13093                 {
13094                         uint32_t _flags_save_string = ndr->flags;
13095                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13096                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13097                         if (_ptr_driver_name) {
13098                                 NDR_PULL_ALLOC(ndr, r->driver_name);
13099                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13100                         } else {
13101                                 r->driver_name = NULL;
13102                         }
13103                         ndr->flags = _flags_save_string;
13104                 }
13105                 {
13106                         uint32_t _flags_save_string = ndr->flags;
13107                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13108                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
13109                         if (_ptr_architecture) {
13110                                 NDR_PULL_ALLOC(ndr, r->architecture);
13111                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
13112                         } else {
13113                                 r->architecture = NULL;
13114                         }
13115                         ndr->flags = _flags_save_string;
13116                 }
13117                 {
13118                         uint32_t _flags_save_string = ndr->flags;
13119                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13120                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
13121                         if (_ptr_driver_path) {
13122                                 NDR_PULL_ALLOC(ndr, r->driver_path);
13123                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
13124                         } else {
13125                                 r->driver_path = NULL;
13126                         }
13127                         ndr->flags = _flags_save_string;
13128                 }
13129                 {
13130                         uint32_t _flags_save_string = ndr->flags;
13131                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13132                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
13133                         if (_ptr_data_file) {
13134                                 NDR_PULL_ALLOC(ndr, r->data_file);
13135                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
13136                         } else {
13137                                 r->data_file = NULL;
13138                         }
13139                         ndr->flags = _flags_save_string;
13140                 }
13141                 {
13142                         uint32_t _flags_save_string = ndr->flags;
13143                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13144                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
13145                         if (_ptr_config_file) {
13146                                 NDR_PULL_ALLOC(ndr, r->config_file);
13147                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
13148                         } else {
13149                                 r->config_file = NULL;
13150                         }
13151                         ndr->flags = _flags_save_string;
13152                 }
13153                 {
13154                         uint32_t _flags_save_string = ndr->flags;
13155                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13156                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
13157                         if (_ptr_help_file) {
13158                                 NDR_PULL_ALLOC(ndr, r->help_file);
13159                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
13160                         } else {
13161                                 r->help_file = NULL;
13162                         }
13163                         ndr->flags = _flags_save_string;
13164                 }
13165                 {
13166                         uint32_t _flags_save_string = ndr->flags;
13167                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13168                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
13169                         if (_ptr_monitor_name) {
13170                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
13171                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
13172                         } else {
13173                                 r->monitor_name = NULL;
13174                         }
13175                         ndr->flags = _flags_save_string;
13176                 }
13177                 {
13178                         uint32_t _flags_save_string = ndr->flags;
13179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13180                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
13181                         if (_ptr_default_datatype) {
13182                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
13183                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
13184                         } else {
13185                                 r->default_datatype = NULL;
13186                         }
13187                         ndr->flags = _flags_save_string;
13188                 }
13189                 {
13190                         uint32_t _flags_save_string_array = ndr->flags;
13191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13192                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
13193                         if (_ptr_dependent_files) {
13194                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
13195                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
13196                         } else {
13197                                 r->dependent_files = NULL;
13198                         }
13199                         ndr->flags = _flags_save_string_array;
13200                 }
13201                 {
13202                         uint32_t _flags_save_string_array = ndr->flags;
13203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13204                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
13205                         if (_ptr_previous_names) {
13206                                 NDR_PULL_ALLOC(ndr, r->previous_names);
13207                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
13208                         } else {
13209                                 r->previous_names = NULL;
13210                         }
13211                         ndr->flags = _flags_save_string_array;
13212                 }
13213                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
13214                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
13215                 {
13216                         uint32_t _flags_save_string = ndr->flags;
13217                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13218                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
13219                         if (_ptr_manufacturer_name) {
13220                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
13221                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
13222                         } else {
13223                                 r->manufacturer_name = NULL;
13224                         }
13225                         ndr->flags = _flags_save_string;
13226                 }
13227                 {
13228                         uint32_t _flags_save_string = ndr->flags;
13229                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13230                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
13231                         if (_ptr_manufacturer_url) {
13232                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
13233                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
13234                         } else {
13235                                 r->manufacturer_url = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
13243                         if (_ptr_hardware_id) {
13244                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
13245                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
13246                         } else {
13247                                 r->hardware_id = NULL;
13248                         }
13249                         ndr->flags = _flags_save_string;
13250                 }
13251                 {
13252                         uint32_t _flags_save_string = ndr->flags;
13253                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13254                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
13255                         if (_ptr_provider) {
13256                                 NDR_PULL_ALLOC(ndr, r->provider);
13257                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
13258                         } else {
13259                                 r->provider = NULL;
13260                         }
13261                         ndr->flags = _flags_save_string;
13262                 }
13263                 {
13264                         uint32_t _flags_save_string = ndr->flags;
13265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13266                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
13267                         if (_ptr_print_processor) {
13268                                 NDR_PULL_ALLOC(ndr, r->print_processor);
13269                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
13270                         } else {
13271                                 r->print_processor = NULL;
13272                         }
13273                         ndr->flags = _flags_save_string;
13274                 }
13275                 {
13276                         uint32_t _flags_save_string = ndr->flags;
13277                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13278                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
13279                         if (_ptr_vendor_setup) {
13280                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
13281                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
13282                         } else {
13283                                 r->vendor_setup = NULL;
13284                         }
13285                         ndr->flags = _flags_save_string;
13286                 }
13287                 {
13288                         uint32_t _flags_save_string_array = ndr->flags;
13289                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13290                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
13291                         if (_ptr_color_profiles) {
13292                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
13293                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
13294                         } else {
13295                                 r->color_profiles = NULL;
13296                         }
13297                         ndr->flags = _flags_save_string_array;
13298                 }
13299                 {
13300                         uint32_t _flags_save_string = ndr->flags;
13301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13302                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
13303                         if (_ptr_inf_path) {
13304                                 NDR_PULL_ALLOC(ndr, r->inf_path);
13305                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
13306                         } else {
13307                                 r->inf_path = NULL;
13308                         }
13309                         ndr->flags = _flags_save_string;
13310                 }
13311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
13312                 {
13313                         uint32_t _flags_save_string_array = ndr->flags;
13314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13315                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
13316                         if (_ptr_core_driver_dependencies) {
13317                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
13318                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
13319                         } else {
13320                                 r->core_driver_dependencies = NULL;
13321                         }
13322                         ndr->flags = _flags_save_string_array;
13323                 }
13324                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
13325                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
13326         }
13327         if (ndr_flags & NDR_BUFFERS) {
13328                 {
13329                         uint32_t _flags_save_string = ndr->flags;
13330                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13331                         if (r->driver_name) {
13332                                 uint32_t _relative_save_offset;
13333                                 _relative_save_offset = ndr->offset;
13334                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13335                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13336                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13337                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13338                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13339                                 ndr->offset = _relative_save_offset;
13340                         }
13341                         ndr->flags = _flags_save_string;
13342                 }
13343                 {
13344                         uint32_t _flags_save_string = ndr->flags;
13345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13346                         if (r->architecture) {
13347                                 uint32_t _relative_save_offset;
13348                                 _relative_save_offset = ndr->offset;
13349                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
13350                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
13351                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
13352                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
13353                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
13354                                 ndr->offset = _relative_save_offset;
13355                         }
13356                         ndr->flags = _flags_save_string;
13357                 }
13358                 {
13359                         uint32_t _flags_save_string = ndr->flags;
13360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13361                         if (r->driver_path) {
13362                                 uint32_t _relative_save_offset;
13363                                 _relative_save_offset = ndr->offset;
13364                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
13365                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13366                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
13367                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
13368                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
13369                                 ndr->offset = _relative_save_offset;
13370                         }
13371                         ndr->flags = _flags_save_string;
13372                 }
13373                 {
13374                         uint32_t _flags_save_string = ndr->flags;
13375                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13376                         if (r->data_file) {
13377                                 uint32_t _relative_save_offset;
13378                                 _relative_save_offset = ndr->offset;
13379                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
13380                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13381                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
13382                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
13383                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
13384                                 ndr->offset = _relative_save_offset;
13385                         }
13386                         ndr->flags = _flags_save_string;
13387                 }
13388                 {
13389                         uint32_t _flags_save_string = ndr->flags;
13390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13391                         if (r->config_file) {
13392                                 uint32_t _relative_save_offset;
13393                                 _relative_save_offset = ndr->offset;
13394                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
13395                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13396                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
13397                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
13398                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
13399                                 ndr->offset = _relative_save_offset;
13400                         }
13401                         ndr->flags = _flags_save_string;
13402                 }
13403                 {
13404                         uint32_t _flags_save_string = ndr->flags;
13405                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13406                         if (r->help_file) {
13407                                 uint32_t _relative_save_offset;
13408                                 _relative_save_offset = ndr->offset;
13409                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
13410                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13411                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
13412                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
13413                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
13414                                 ndr->offset = _relative_save_offset;
13415                         }
13416                         ndr->flags = _flags_save_string;
13417                 }
13418                 {
13419                         uint32_t _flags_save_string = ndr->flags;
13420                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13421                         if (r->monitor_name) {
13422                                 uint32_t _relative_save_offset;
13423                                 _relative_save_offset = ndr->offset;
13424                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
13425                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13426                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
13427                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
13428                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
13429                                 ndr->offset = _relative_save_offset;
13430                         }
13431                         ndr->flags = _flags_save_string;
13432                 }
13433                 {
13434                         uint32_t _flags_save_string = ndr->flags;
13435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13436                         if (r->default_datatype) {
13437                                 uint32_t _relative_save_offset;
13438                                 _relative_save_offset = ndr->offset;
13439                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
13440                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
13441                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
13442                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
13443                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
13444                                 ndr->offset = _relative_save_offset;
13445                         }
13446                         ndr->flags = _flags_save_string;
13447                 }
13448                 {
13449                         uint32_t _flags_save_string_array = ndr->flags;
13450                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13451                         if (r->dependent_files) {
13452                                 uint32_t _relative_save_offset;
13453                                 _relative_save_offset = ndr->offset;
13454                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
13455                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
13456                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
13457                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
13458                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
13459                                 ndr->offset = _relative_save_offset;
13460                         }
13461                         ndr->flags = _flags_save_string_array;
13462                 }
13463                 {
13464                         uint32_t _flags_save_string_array = ndr->flags;
13465                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13466                         if (r->previous_names) {
13467                                 uint32_t _relative_save_offset;
13468                                 _relative_save_offset = ndr->offset;
13469                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
13470                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
13471                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
13472                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
13473                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
13474                                 ndr->offset = _relative_save_offset;
13475                         }
13476                         ndr->flags = _flags_save_string_array;
13477                 }
13478                 {
13479                         uint32_t _flags_save_string = ndr->flags;
13480                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13481                         if (r->manufacturer_name) {
13482                                 uint32_t _relative_save_offset;
13483                                 _relative_save_offset = ndr->offset;
13484                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
13485                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13486                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
13487                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
13488                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
13489                                 ndr->offset = _relative_save_offset;
13490                         }
13491                         ndr->flags = _flags_save_string;
13492                 }
13493                 {
13494                         uint32_t _flags_save_string = ndr->flags;
13495                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13496                         if (r->manufacturer_url) {
13497                                 uint32_t _relative_save_offset;
13498                                 _relative_save_offset = ndr->offset;
13499                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
13500                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
13501                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
13502                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
13503                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13504                                 ndr->offset = _relative_save_offset;
13505                         }
13506                         ndr->flags = _flags_save_string;
13507                 }
13508                 {
13509                         uint32_t _flags_save_string = ndr->flags;
13510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13511                         if (r->hardware_id) {
13512                                 uint32_t _relative_save_offset;
13513                                 _relative_save_offset = ndr->offset;
13514                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13515                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13516                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13517                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13518                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13519                                 ndr->offset = _relative_save_offset;
13520                         }
13521                         ndr->flags = _flags_save_string;
13522                 }
13523                 {
13524                         uint32_t _flags_save_string = ndr->flags;
13525                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13526                         if (r->provider) {
13527                                 uint32_t _relative_save_offset;
13528                                 _relative_save_offset = ndr->offset;
13529                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13530                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13531                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13532                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13533                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13534                                 ndr->offset = _relative_save_offset;
13535                         }
13536                         ndr->flags = _flags_save_string;
13537                 }
13538                 {
13539                         uint32_t _flags_save_string = ndr->flags;
13540                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13541                         if (r->print_processor) {
13542                                 uint32_t _relative_save_offset;
13543                                 _relative_save_offset = ndr->offset;
13544                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
13545                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
13546                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
13547                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
13548                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
13549                                 ndr->offset = _relative_save_offset;
13550                         }
13551                         ndr->flags = _flags_save_string;
13552                 }
13553                 {
13554                         uint32_t _flags_save_string = ndr->flags;
13555                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13556                         if (r->vendor_setup) {
13557                                 uint32_t _relative_save_offset;
13558                                 _relative_save_offset = ndr->offset;
13559                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
13560                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
13561                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
13562                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
13563                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
13564                                 ndr->offset = _relative_save_offset;
13565                         }
13566                         ndr->flags = _flags_save_string;
13567                 }
13568                 {
13569                         uint32_t _flags_save_string_array = ndr->flags;
13570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13571                         if (r->color_profiles) {
13572                                 uint32_t _relative_save_offset;
13573                                 _relative_save_offset = ndr->offset;
13574                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
13575                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
13576                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
13577                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
13578                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
13579                                 ndr->offset = _relative_save_offset;
13580                         }
13581                         ndr->flags = _flags_save_string_array;
13582                 }
13583                 {
13584                         uint32_t _flags_save_string = ndr->flags;
13585                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13586                         if (r->inf_path) {
13587                                 uint32_t _relative_save_offset;
13588                                 _relative_save_offset = ndr->offset;
13589                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
13590                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13591                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
13592                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
13593                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
13594                                 ndr->offset = _relative_save_offset;
13595                         }
13596                         ndr->flags = _flags_save_string;
13597                 }
13598                 {
13599                         uint32_t _flags_save_string_array = ndr->flags;
13600                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13601                         if (r->core_driver_dependencies) {
13602                                 uint32_t _relative_save_offset;
13603                                 _relative_save_offset = ndr->offset;
13604                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
13605                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13606                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
13607                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
13608                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
13609                                 ndr->offset = _relative_save_offset;
13610                         }
13611                         ndr->flags = _flags_save_string_array;
13612                 }
13613         }
13614         return NDR_ERR_SUCCESS;
13615 }
13616
13617 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
13618 {
13619         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
13620         ndr->depth++;
13621         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13622         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13623         ndr->depth++;
13624         if (r->driver_name) {
13625                 ndr_print_string(ndr, "driver_name", r->driver_name);
13626         }
13627         ndr->depth--;
13628         ndr_print_ptr(ndr, "architecture", r->architecture);
13629         ndr->depth++;
13630         if (r->architecture) {
13631                 ndr_print_string(ndr, "architecture", r->architecture);
13632         }
13633         ndr->depth--;
13634         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13635         ndr->depth++;
13636         if (r->driver_path) {
13637                 ndr_print_string(ndr, "driver_path", r->driver_path);
13638         }
13639         ndr->depth--;
13640         ndr_print_ptr(ndr, "data_file", r->data_file);
13641         ndr->depth++;
13642         if (r->data_file) {
13643                 ndr_print_string(ndr, "data_file", r->data_file);
13644         }
13645         ndr->depth--;
13646         ndr_print_ptr(ndr, "config_file", r->config_file);
13647         ndr->depth++;
13648         if (r->config_file) {
13649                 ndr_print_string(ndr, "config_file", r->config_file);
13650         }
13651         ndr->depth--;
13652         ndr_print_ptr(ndr, "help_file", r->help_file);
13653         ndr->depth++;
13654         if (r->help_file) {
13655                 ndr_print_string(ndr, "help_file", r->help_file);
13656         }
13657         ndr->depth--;
13658         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13659         ndr->depth++;
13660         if (r->monitor_name) {
13661                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13662         }
13663         ndr->depth--;
13664         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13665         ndr->depth++;
13666         if (r->default_datatype) {
13667                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13668         }
13669         ndr->depth--;
13670         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13671         ndr->depth++;
13672         if (r->dependent_files) {
13673                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13674         }
13675         ndr->depth--;
13676         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13677         ndr->depth++;
13678         if (r->previous_names) {
13679                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13680         }
13681         ndr->depth--;
13682         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13683         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13684         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13685         ndr->depth++;
13686         if (r->manufacturer_name) {
13687                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13688         }
13689         ndr->depth--;
13690         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13691         ndr->depth++;
13692         if (r->manufacturer_url) {
13693                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13694         }
13695         ndr->depth--;
13696         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13697         ndr->depth++;
13698         if (r->hardware_id) {
13699                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13700         }
13701         ndr->depth--;
13702         ndr_print_ptr(ndr, "provider", r->provider);
13703         ndr->depth++;
13704         if (r->provider) {
13705                 ndr_print_string(ndr, "provider", r->provider);
13706         }
13707         ndr->depth--;
13708         ndr_print_ptr(ndr, "print_processor", r->print_processor);
13709         ndr->depth++;
13710         if (r->print_processor) {
13711                 ndr_print_string(ndr, "print_processor", r->print_processor);
13712         }
13713         ndr->depth--;
13714         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
13715         ndr->depth++;
13716         if (r->vendor_setup) {
13717                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
13718         }
13719         ndr->depth--;
13720         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
13721         ndr->depth++;
13722         if (r->color_profiles) {
13723                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
13724         }
13725         ndr->depth--;
13726         ndr_print_ptr(ndr, "inf_path", r->inf_path);
13727         ndr->depth++;
13728         if (r->inf_path) {
13729                 ndr_print_string(ndr, "inf_path", r->inf_path);
13730         }
13731         ndr->depth--;
13732         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
13733         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13734         ndr->depth++;
13735         if (r->core_driver_dependencies) {
13736                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13737         }
13738         ndr->depth--;
13739         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
13740         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
13741         ndr->depth--;
13742 }
13743
13744 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
13745 {
13746         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
13747 }
13748
13749 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
13750 {
13751         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13752         return NDR_ERR_SUCCESS;
13753 }
13754
13755 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
13756 {
13757         uint32_t v;
13758         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13759         *r = v;
13760         return NDR_ERR_SUCCESS;
13761 }
13762
13763 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
13764 {
13765         const char *val = NULL;
13766
13767         switch (r) {
13768                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
13769                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
13770                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
13771                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
13772                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
13773         }
13774         ndr_print_enum(ndr, name, "ENUM", val, r);
13775 }
13776
13777 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
13778 {
13779         if (ndr_flags & NDR_SCALARS) {
13780                 NDR_CHECK(ndr_push_align(ndr, 4));
13781                 {
13782                         uint32_t _flags_save_string = ndr->flags;
13783                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13784                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
13785                         ndr->flags = _flags_save_string;
13786                 }
13787                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
13788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
13789         }
13790         if (ndr_flags & NDR_BUFFERS) {
13791                 {
13792                         uint32_t _flags_save_string = ndr->flags;
13793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13794                         if (r->file_name) {
13795                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
13796                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
13797                         }
13798                         ndr->flags = _flags_save_string;
13799                 }
13800         }
13801         return NDR_ERR_SUCCESS;
13802 }
13803
13804 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
13805 {
13806         uint32_t _ptr_file_name;
13807         TALLOC_CTX *_mem_save_file_name_0;
13808         if (ndr_flags & NDR_SCALARS) {
13809                 NDR_CHECK(ndr_pull_align(ndr, 4));
13810                 {
13811                         uint32_t _flags_save_string = ndr->flags;
13812                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13813                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
13814                         if (_ptr_file_name) {
13815                                 NDR_PULL_ALLOC(ndr, r->file_name);
13816                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
13817                         } else {
13818                                 r->file_name = NULL;
13819                         }
13820                         ndr->flags = _flags_save_string;
13821                 }
13822                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
13823                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
13824         }
13825         if (ndr_flags & NDR_BUFFERS) {
13826                 {
13827                         uint32_t _flags_save_string = ndr->flags;
13828                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13829                         if (r->file_name) {
13830                                 uint32_t _relative_save_offset;
13831                                 _relative_save_offset = ndr->offset;
13832                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
13833                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13834                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
13835                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
13836                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
13837                                 ndr->offset = _relative_save_offset;
13838                         }
13839                         ndr->flags = _flags_save_string;
13840                 }
13841         }
13842         return NDR_ERR_SUCCESS;
13843 }
13844
13845 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
13846 {
13847         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
13848         ndr->depth++;
13849         ndr_print_ptr(ndr, "file_name", r->file_name);
13850         ndr->depth++;
13851         if (r->file_name) {
13852                 ndr_print_string(ndr, "file_name", r->file_name);
13853         }
13854         ndr->depth--;
13855         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
13856         ndr_print_uint32(ndr, "file_version", r->file_version);
13857         ndr->depth--;
13858 }
13859
13860 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
13861 {
13862         uint32_t cntr_file_info_1;
13863         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
13864         ndr->depth++;
13865         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13866         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13867         ndr->depth++;
13868         if (r->driver_name) {
13869                 ndr_print_string(ndr, "driver_name", r->driver_name);
13870         }
13871         ndr->depth--;
13872         ndr_print_ptr(ndr, "architecture", r->architecture);
13873         ndr->depth++;
13874         if (r->architecture) {
13875                 ndr_print_string(ndr, "architecture", r->architecture);
13876         }
13877         ndr->depth--;
13878         ndr_print_ptr(ndr, "file_info", r->file_info);
13879         ndr->depth++;
13880         if (r->file_info) {
13881                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
13882                 ndr->depth++;
13883                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
13884                         char *idx_1=NULL;
13885                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
13886                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
13887                                 free(idx_1);
13888                         }
13889                 }
13890                 ndr->depth--;
13891         }
13892         ndr->depth--;
13893         ndr_print_uint32(ndr, "file_count", r->file_count);
13894         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13895         ndr->depth++;
13896         if (r->monitor_name) {
13897                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13898         }
13899         ndr->depth--;
13900         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13901         ndr->depth++;
13902         if (r->default_datatype) {
13903                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13904         }
13905         ndr->depth--;
13906         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13907         ndr->depth++;
13908         if (r->previous_names) {
13909                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13910         }
13911         ndr->depth--;
13912         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13913         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13914         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13915         ndr->depth++;
13916         if (r->manufacturer_name) {
13917                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13918         }
13919         ndr->depth--;
13920         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13921         ndr->depth++;
13922         if (r->manufacturer_url) {
13923                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13924         }
13925         ndr->depth--;
13926         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13927         ndr->depth++;
13928         if (r->hardware_id) {
13929                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13930         }
13931         ndr->depth--;
13932         ndr_print_ptr(ndr, "provider", r->provider);
13933         ndr->depth++;
13934         if (r->provider) {
13935                 ndr_print_string(ndr, "provider", r->provider);
13936         }
13937         ndr->depth--;
13938         ndr->depth--;
13939 }
13940
13941 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
13942 {
13943         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
13944 }
13945
13946 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
13947 {
13948         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13949         if (ndr_flags & NDR_SCALARS) {
13950                 int level = ndr_push_get_switch_value(ndr, r);
13951                 switch (level) {
13952                         case 1: {
13953                                 NDR_CHECK(ndr_push_align(ndr, 4));
13954                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13955                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13956                         break; }
13957
13958                         case 2: {
13959                                 NDR_CHECK(ndr_push_align(ndr, 4));
13960                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13961                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13962                         break; }
13963
13964                         case 3: {
13965                                 NDR_CHECK(ndr_push_align(ndr, 4));
13966                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13967                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13968                         break; }
13969
13970                         case 4: {
13971                                 NDR_CHECK(ndr_push_align(ndr, 4));
13972                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13973                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13974                         break; }
13975
13976                         case 5: {
13977                                 NDR_CHECK(ndr_push_align(ndr, 4));
13978                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13979                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13980                         break; }
13981
13982                         case 6: {
13983                                 NDR_CHECK(ndr_push_align(ndr, 8));
13984                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13985                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13986                         break; }
13987
13988                         case 8: {
13989                                 NDR_CHECK(ndr_push_align(ndr, 8));
13990                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13991                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13992                         break; }
13993
13994                         case 101: {
13995                                 NDR_CHECK(ndr_push_align(ndr, 8));
13996                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13997                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13998                         break; }
13999
14000                         default: {
14001                         break; }
14002
14003                 }
14004         }
14005         if (ndr_flags & NDR_BUFFERS) {
14006                 int level = ndr_push_get_switch_value(ndr, r);
14007                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14008                 switch (level) {
14009                         case 1:
14010                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14011                         break;
14012
14013                         case 2:
14014                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14015                         break;
14016
14017                         case 3:
14018                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14019                         break;
14020
14021                         case 4:
14022                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14023                         break;
14024
14025                         case 5:
14026                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14027                         break;
14028
14029                         case 6:
14030                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14031                         break;
14032
14033                         case 8:
14034                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14035                         break;
14036
14037                         case 101:
14038                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14039                         break;
14040
14041                         default:
14042                         break;
14043
14044                 }
14045         }
14046         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14047         return NDR_ERR_SUCCESS;
14048 }
14049
14050 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
14051 {
14052         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14053         int level;
14054         level = ndr_pull_get_switch_value(ndr, r);
14055         if (ndr_flags & NDR_SCALARS) {
14056                 switch (level) {
14057                         case 1: {
14058                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14059                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14060                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14061                         break; }
14062
14063                         case 2: {
14064                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14065                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14066                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14067                         break; }
14068
14069                         case 3: {
14070                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14071                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14072                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14073                         break; }
14074
14075                         case 4: {
14076                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14077                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14078                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14079                         break; }
14080
14081                         case 5: {
14082                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14083                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14084                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14085                         break; }
14086
14087                         case 6: {
14088                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14089                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14090                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14091                         break; }
14092
14093                         case 8: {
14094                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14095                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14096                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14097                         break; }
14098
14099                         case 101: {
14100                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14101                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14102                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14103                         break; }
14104
14105                         default: {
14106                         break; }
14107
14108                 }
14109         }
14110         if (ndr_flags & NDR_BUFFERS) {
14111                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14112                 switch (level) {
14113                         case 1:
14114                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14115                         break;
14116
14117                         case 2:
14118                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14119                         break;
14120
14121                         case 3:
14122                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14123                         break;
14124
14125                         case 4:
14126                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14127                         break;
14128
14129                         case 5:
14130                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14131                         break;
14132
14133                         case 6:
14134                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14135                         break;
14136
14137                         case 8:
14138                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14139                         break;
14140
14141                         case 101:
14142                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14143                         break;
14144
14145                         default:
14146                         break;
14147
14148                 }
14149         }
14150         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14151         return NDR_ERR_SUCCESS;
14152 }
14153
14154 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
14155 {
14156         int level;
14157         level = ndr_print_get_switch_value(ndr, r);
14158         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
14159         switch (level) {
14160                 case 1:
14161                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
14162                 break;
14163
14164                 case 2:
14165                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
14166                 break;
14167
14168                 case 3:
14169                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
14170                 break;
14171
14172                 case 4:
14173                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
14174                 break;
14175
14176                 case 5:
14177                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
14178                 break;
14179
14180                 case 6:
14181                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
14182                 break;
14183
14184                 case 8:
14185                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
14186                 break;
14187
14188                 case 101:
14189                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
14190                 break;
14191
14192                 default:
14193                 break;
14194
14195         }
14196 }
14197
14198 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14199 {
14200         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
14201 }
14202
14203 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
14204 {
14205         if (ndr_flags & NDR_SCALARS) {
14206                 NDR_CHECK(ndr_push_align(ndr, 4));
14207                 {
14208                         uint32_t _flags_save_string = ndr->flags;
14209                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14210                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14211                         ndr->flags = _flags_save_string;
14212                 }
14213         }
14214         if (ndr_flags & NDR_BUFFERS) {
14215         }
14216         return NDR_ERR_SUCCESS;
14217 }
14218
14219 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
14220 {
14221         if (ndr_flags & NDR_SCALARS) {
14222                 NDR_CHECK(ndr_pull_align(ndr, 4));
14223                 {
14224                         uint32_t _flags_save_string = ndr->flags;
14225                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14226                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14227                         ndr->flags = _flags_save_string;
14228                 }
14229         }
14230         if (ndr_flags & NDR_BUFFERS) {
14231         }
14232         return NDR_ERR_SUCCESS;
14233 }
14234
14235 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
14236 {
14237         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
14238         ndr->depth++;
14239         ndr_print_string(ndr, "directory_name", r->directory_name);
14240         ndr->depth--;
14241 }
14242
14243 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14244 {
14245         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
14246 }
14247
14248 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
14249 {
14250         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14251         if (ndr_flags & NDR_SCALARS) {
14252                 int level = ndr_push_get_switch_value(ndr, r);
14253                 switch (level) {
14254                         case 1: {
14255                                 NDR_CHECK(ndr_push_align(ndr, 4));
14256                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14257                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14258                         break; }
14259
14260                         default: {
14261                                 NDR_CHECK(ndr_push_align(ndr, 4));
14262                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14263                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14264                         break; }
14265
14266                 }
14267         }
14268         if (ndr_flags & NDR_BUFFERS) {
14269                 int level = ndr_push_get_switch_value(ndr, r);
14270                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14271                 switch (level) {
14272                         case 1:
14273                         break;
14274
14275                         default:
14276                         break;
14277
14278                 }
14279         }
14280         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14281         return NDR_ERR_SUCCESS;
14282 }
14283
14284 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
14285 {
14286         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14287         int level;
14288         level = ndr_pull_get_switch_value(ndr, r);
14289         if (ndr_flags & NDR_SCALARS) {
14290                 switch (level) {
14291                         case 1: {
14292                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14293                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14294                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14295                         break; }
14296
14297                         default: {
14298                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14299                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14300                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14301                         break; }
14302
14303                 }
14304         }
14305         if (ndr_flags & NDR_BUFFERS) {
14306                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14307                 switch (level) {
14308                         case 1:
14309                         break;
14310
14311                         default:
14312                         break;
14313
14314                 }
14315         }
14316         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14317         return NDR_ERR_SUCCESS;
14318 }
14319
14320 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
14321 {
14322         int level;
14323         level = ndr_print_get_switch_value(ndr, r);
14324         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
14325         switch (level) {
14326                 case 1:
14327                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
14328                 break;
14329
14330                 default:
14331                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
14332                 break;
14333
14334         }
14335 }
14336
14337 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14338 {
14339         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
14340 }
14341
14342 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
14343 {
14344         if (ndr_flags & NDR_SCALARS) {
14345                 NDR_CHECK(ndr_push_align(ndr, 4));
14346                 {
14347                         uint32_t _flags_save_string = ndr->flags;
14348                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14349                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
14350                         ndr->flags = _flags_save_string;
14351                 }
14352         }
14353         if (ndr_flags & NDR_BUFFERS) {
14354                 {
14355                         uint32_t _flags_save_string = ndr->flags;
14356                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14357                         if (r->print_processor_name) {
14358                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
14359                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
14360                         }
14361                         ndr->flags = _flags_save_string;
14362                 }
14363         }
14364         return NDR_ERR_SUCCESS;
14365 }
14366
14367 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
14368 {
14369         uint32_t _ptr_print_processor_name;
14370         TALLOC_CTX *_mem_save_print_processor_name_0;
14371         if (ndr_flags & NDR_SCALARS) {
14372                 NDR_CHECK(ndr_pull_align(ndr, 4));
14373                 {
14374                         uint32_t _flags_save_string = ndr->flags;
14375                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14376                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
14377                         if (_ptr_print_processor_name) {
14378                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
14379                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
14380                         } else {
14381                                 r->print_processor_name = NULL;
14382                         }
14383                         ndr->flags = _flags_save_string;
14384                 }
14385         }
14386         if (ndr_flags & NDR_BUFFERS) {
14387                 {
14388                         uint32_t _flags_save_string = ndr->flags;
14389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14390                         if (r->print_processor_name) {
14391                                 uint32_t _relative_save_offset;
14392                                 _relative_save_offset = ndr->offset;
14393                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
14394                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14395                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
14396                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
14397                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
14398                                 ndr->offset = _relative_save_offset;
14399                         }
14400                         ndr->flags = _flags_save_string;
14401                 }
14402         }
14403         return NDR_ERR_SUCCESS;
14404 }
14405
14406 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
14407 {
14408         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
14409         ndr->depth++;
14410         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
14411         ndr->depth++;
14412         if (r->print_processor_name) {
14413                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
14414         }
14415         ndr->depth--;
14416         ndr->depth--;
14417 }
14418
14419 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14420 {
14421         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
14422 }
14423
14424 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
14425 {
14426         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14427         if (ndr_flags & NDR_SCALARS) {
14428                 int level = ndr_push_get_switch_value(ndr, r);
14429                 switch (level) {
14430                         case 1: {
14431                                 NDR_CHECK(ndr_push_align(ndr, 4));
14432                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14433                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
14434                         break; }
14435
14436                         default: {
14437                         break; }
14438
14439                 }
14440         }
14441         if (ndr_flags & NDR_BUFFERS) {
14442                 int level = ndr_push_get_switch_value(ndr, r);
14443                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14444                 switch (level) {
14445                         case 1:
14446                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
14447                         break;
14448
14449                         default:
14450                         break;
14451
14452                 }
14453         }
14454         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14455         return NDR_ERR_SUCCESS;
14456 }
14457
14458 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
14459 {
14460         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14461         int level;
14462         level = ndr_pull_get_switch_value(ndr, r);
14463         if (ndr_flags & NDR_SCALARS) {
14464                 switch (level) {
14465                         case 1: {
14466                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14467                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14468                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
14469                         break; }
14470
14471                         default: {
14472                         break; }
14473
14474                 }
14475         }
14476         if (ndr_flags & NDR_BUFFERS) {
14477                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14478                 switch (level) {
14479                         case 1:
14480                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
14481                         break;
14482
14483                         default:
14484                         break;
14485
14486                 }
14487         }
14488         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14489         return NDR_ERR_SUCCESS;
14490 }
14491
14492 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
14493 {
14494         int level;
14495         level = ndr_print_get_switch_value(ndr, r);
14496         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
14497         switch (level) {
14498                 case 1:
14499                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
14500                 break;
14501
14502                 default:
14503                 break;
14504
14505         }
14506 }
14507
14508 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14509 {
14510         if (ndr_flags & NDR_SCALARS) {
14511                 NDR_CHECK(ndr_push_align(ndr, 4));
14512                 {
14513                         uint32_t _flags_save_string = ndr->flags;
14514                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14515                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14516                         ndr->flags = _flags_save_string;
14517                 }
14518         }
14519         if (ndr_flags & NDR_BUFFERS) {
14520         }
14521         return NDR_ERR_SUCCESS;
14522 }
14523
14524 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
14525 {
14526         if (ndr_flags & NDR_SCALARS) {
14527                 NDR_CHECK(ndr_pull_align(ndr, 4));
14528                 {
14529                         uint32_t _flags_save_string = ndr->flags;
14530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14531                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14532                         ndr->flags = _flags_save_string;
14533                 }
14534         }
14535         if (ndr_flags & NDR_BUFFERS) {
14536         }
14537         return NDR_ERR_SUCCESS;
14538 }
14539
14540 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14541 {
14542         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
14543         ndr->depth++;
14544         ndr_print_string(ndr, "directory_name", r->directory_name);
14545         ndr->depth--;
14546 }
14547
14548 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14549 {
14550         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
14551 }
14552
14553 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
14554 {
14555         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14556         if (ndr_flags & NDR_SCALARS) {
14557                 int level = ndr_push_get_switch_value(ndr, r);
14558                 switch (level) {
14559                         case 1: {
14560                                 NDR_CHECK(ndr_push_align(ndr, 4));
14561                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14562                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14563                         break; }
14564
14565                         default: {
14566                                 NDR_CHECK(ndr_push_align(ndr, 4));
14567                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14568                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14569                         break; }
14570
14571                 }
14572         }
14573         if (ndr_flags & NDR_BUFFERS) {
14574                 int level = ndr_push_get_switch_value(ndr, r);
14575                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14576                 switch (level) {
14577                         case 1:
14578                         break;
14579
14580                         default:
14581                         break;
14582
14583                 }
14584         }
14585         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14586         return NDR_ERR_SUCCESS;
14587 }
14588
14589 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
14590 {
14591         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14592         int level;
14593         level = ndr_pull_get_switch_value(ndr, r);
14594         if (ndr_flags & NDR_SCALARS) {
14595                 switch (level) {
14596                         case 1: {
14597                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14598                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14599                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14600                         break; }
14601
14602                         default: {
14603                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14604                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14605                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14606                         break; }
14607
14608                 }
14609         }
14610         if (ndr_flags & NDR_BUFFERS) {
14611                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14612                 switch (level) {
14613                         case 1:
14614                         break;
14615
14616                         default:
14617                         break;
14618
14619                 }
14620         }
14621         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14622         return NDR_ERR_SUCCESS;
14623 }
14624
14625 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
14626 {
14627         int level;
14628         level = ndr_print_get_switch_value(ndr, r);
14629         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
14630         switch (level) {
14631                 case 1:
14632                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14633                 break;
14634
14635                 default:
14636                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14637                 break;
14638
14639         }
14640 }
14641
14642 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14643 {
14644         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
14645 }
14646
14647 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
14648 {
14649         if (ndr_flags & NDR_SCALARS) {
14650                 NDR_CHECK(ndr_push_align(ndr, 4));
14651                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
14652                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
14653                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
14654         }
14655         if (ndr_flags & NDR_BUFFERS) {
14656                 if (r->document_name) {
14657                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14658                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14659                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14660                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14661                 }
14662                 if (r->output_file) {
14663                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14664                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14665                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14666                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14667                 }
14668                 if (r->datatype) {
14669                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14670                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14671                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14672                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14673                 }
14674         }
14675         return NDR_ERR_SUCCESS;
14676 }
14677
14678 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
14679 {
14680         uint32_t _ptr_document_name;
14681         TALLOC_CTX *_mem_save_document_name_0;
14682         uint32_t _ptr_output_file;
14683         TALLOC_CTX *_mem_save_output_file_0;
14684         uint32_t _ptr_datatype;
14685         TALLOC_CTX *_mem_save_datatype_0;
14686         if (ndr_flags & NDR_SCALARS) {
14687                 NDR_CHECK(ndr_pull_align(ndr, 4));
14688                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
14689                 if (_ptr_document_name) {
14690                         NDR_PULL_ALLOC(ndr, r->document_name);
14691                 } else {
14692                         r->document_name = NULL;
14693                 }
14694                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
14695                 if (_ptr_output_file) {
14696                         NDR_PULL_ALLOC(ndr, r->output_file);
14697                 } else {
14698                         r->output_file = NULL;
14699                 }
14700                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14701                 if (_ptr_datatype) {
14702                         NDR_PULL_ALLOC(ndr, r->datatype);
14703                 } else {
14704                         r->datatype = NULL;
14705                 }
14706         }
14707         if (ndr_flags & NDR_BUFFERS) {
14708                 if (r->document_name) {
14709                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14710                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
14711                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
14712                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
14713                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
14714                                 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));
14715                         }
14716                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
14717                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
14718                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
14719                 }
14720                 if (r->output_file) {
14721                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14722                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
14723                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
14724                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
14725                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
14726                                 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));
14727                         }
14728                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
14729                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
14730                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
14731                 }
14732                 if (r->datatype) {
14733                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14734                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
14735                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
14736                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
14737                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
14738                                 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));
14739                         }
14740                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
14741                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
14742                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14743                 }
14744         }
14745         return NDR_ERR_SUCCESS;
14746 }
14747
14748 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
14749 {
14750         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
14751         ndr->depth++;
14752         ndr_print_ptr(ndr, "document_name", r->document_name);
14753         ndr->depth++;
14754         if (r->document_name) {
14755                 ndr_print_string(ndr, "document_name", r->document_name);
14756         }
14757         ndr->depth--;
14758         ndr_print_ptr(ndr, "output_file", r->output_file);
14759         ndr->depth++;
14760         if (r->output_file) {
14761                 ndr_print_string(ndr, "output_file", r->output_file);
14762         }
14763         ndr->depth--;
14764         ndr_print_ptr(ndr, "datatype", r->datatype);
14765         ndr->depth++;
14766         if (r->datatype) {
14767                 ndr_print_string(ndr, "datatype", r->datatype);
14768         }
14769         ndr->depth--;
14770         ndr->depth--;
14771 }
14772
14773 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
14774 {
14775         if (ndr_flags & NDR_SCALARS) {
14776                 int level = ndr_push_get_switch_value(ndr, r);
14777                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14778                 switch (level) {
14779                         case 1: {
14780                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
14781                         break; }
14782
14783                         case 2: {
14784                         break; }
14785
14786                         case 3: {
14787                         break; }
14788
14789                         default: {
14790                         break; }
14791
14792                 }
14793         }
14794         if (ndr_flags & NDR_BUFFERS) {
14795                 int level = ndr_push_get_switch_value(ndr, r);
14796                 switch (level) {
14797                         case 1:
14798                                 if (r->info1) {
14799                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14800                                 }
14801                         break;
14802
14803                         case 2:
14804                         break;
14805
14806                         case 3:
14807                         break;
14808
14809                         default:
14810                         break;
14811
14812                 }
14813         }
14814         return NDR_ERR_SUCCESS;
14815 }
14816
14817 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
14818 {
14819         int level;
14820         uint32_t _level;
14821         TALLOC_CTX *_mem_save_info1_0;
14822         level = ndr_pull_get_switch_value(ndr, r);
14823         if (ndr_flags & NDR_SCALARS) {
14824                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14825                 if (_level != level) {
14826                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14827                 }
14828                 switch (level) {
14829                         case 1: {
14830                                 uint32_t _ptr_info1;
14831                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
14832                                 if (_ptr_info1) {
14833                                         NDR_PULL_ALLOC(ndr, r->info1);
14834                                 } else {
14835                                         r->info1 = NULL;
14836                                 }
14837                         break; }
14838
14839                         case 2: {
14840                         break; }
14841
14842                         case 3: {
14843                         break; }
14844
14845                         default: {
14846                         break; }
14847
14848                 }
14849         }
14850         if (ndr_flags & NDR_BUFFERS) {
14851                 switch (level) {
14852                         case 1:
14853                                 if (r->info1) {
14854                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14855                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
14856                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14857                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
14858                                 }
14859                         break;
14860
14861                         case 2:
14862                         break;
14863
14864                         case 3:
14865                         break;
14866
14867                         default:
14868                         break;
14869
14870                 }
14871         }
14872         return NDR_ERR_SUCCESS;
14873 }
14874
14875 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
14876 {
14877         int level;
14878         level = ndr_print_get_switch_value(ndr, r);
14879         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
14880         switch (level) {
14881                 case 1:
14882                         ndr_print_ptr(ndr, "info1", r->info1);
14883                         ndr->depth++;
14884                         if (r->info1) {
14885                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
14886                         }
14887                         ndr->depth--;
14888                 break;
14889
14890                 case 2:
14891                 break;
14892
14893                 case 3:
14894                 break;
14895
14896                 default:
14897                 break;
14898
14899         }
14900 }
14901
14902 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
14903 {
14904         if (ndr_flags & NDR_SCALARS) {
14905                 NDR_CHECK(ndr_push_align(ndr, 4));
14906                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
14907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14911                 {
14912                         uint32_t _flags_save_string = ndr->flags;
14913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14914                         {
14915                                 struct ndr_push *_ndr_extra_string;
14916                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14917                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14918                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14919                         }
14920                         ndr->flags = _flags_save_string;
14921                 }
14922         }
14923         if (ndr_flags & NDR_BUFFERS) {
14924         }
14925         return NDR_ERR_SUCCESS;
14926 }
14927
14928 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
14929 {
14930         if (ndr_flags & NDR_SCALARS) {
14931                 NDR_CHECK(ndr_pull_align(ndr, 4));
14932                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14934                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14936                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
14937                 {
14938                         uint32_t _flags_save_string = ndr->flags;
14939                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14940                         {
14941                                 struct ndr_pull *_ndr_extra_string;
14942                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14943                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14944                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14945                         }
14946                         ndr->flags = _flags_save_string;
14947                 }
14948         }
14949         if (ndr_flags & NDR_BUFFERS) {
14950         }
14951         return NDR_ERR_SUCCESS;
14952 }
14953
14954 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
14955 {
14956         ndr_print_struct(ndr, name, "spoolss_OSVersion");
14957         ndr->depth++;
14958         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);
14959         ndr_print_uint32(ndr, "major", r->major);
14960         ndr_print_uint32(ndr, "minor", r->minor);
14961         ndr_print_uint32(ndr, "build", r->build);
14962         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
14963         ndr_print_string(ndr, "extra_string", r->extra_string);
14964         ndr->depth--;
14965 }
14966
14967 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
14968 {
14969         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
14970 }
14971
14972 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
14973 {
14974         if (ndr_flags & NDR_SCALARS) {
14975                 NDR_CHECK(ndr_push_align(ndr, 4));
14976                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
14977                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14981                 {
14982                         uint32_t _flags_save_string = ndr->flags;
14983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14984                         {
14985                                 struct ndr_push *_ndr_extra_string;
14986                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14987                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14988                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14989                         }
14990                         ndr->flags = _flags_save_string;
14991                 }
14992                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_major));
14993                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_minor));
14994                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->suite_mask));
14995                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->product_type));
14996                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->reserved));
14997         }
14998         if (ndr_flags & NDR_BUFFERS) {
14999         }
15000         return NDR_ERR_SUCCESS;
15001 }
15002
15003 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
15004 {
15005         if (ndr_flags & NDR_SCALARS) {
15006                 NDR_CHECK(ndr_pull_align(ndr, 4));
15007                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15008                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15009                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15012                 {
15013                         uint32_t _flags_save_string = ndr->flags;
15014                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15015                         {
15016                                 struct ndr_pull *_ndr_extra_string;
15017                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15018                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15019                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15020                         }
15021                         ndr->flags = _flags_save_string;
15022                 }
15023                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_major));
15024                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_minor));
15025                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->suite_mask));
15026                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->product_type));
15027                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->reserved));
15028         }
15029         if (ndr_flags & NDR_BUFFERS) {
15030         }
15031         return NDR_ERR_SUCCESS;
15032 }
15033
15034 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
15035 {
15036         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
15037         ndr->depth++;
15038         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);
15039         ndr_print_uint32(ndr, "major", r->major);
15040         ndr_print_uint32(ndr, "minor", r->minor);
15041         ndr_print_uint32(ndr, "build", r->build);
15042         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15043         ndr_print_string(ndr, "extra_string", r->extra_string);
15044         ndr_print_uint16(ndr, "service_pack_major", r->service_pack_major);
15045         ndr_print_uint16(ndr, "service_pack_minor", r->service_pack_minor);
15046         ndr_print_uint16(ndr, "suite_mask", r->suite_mask);
15047         ndr_print_uint8(ndr, "product_type", r->product_type);
15048         ndr_print_uint8(ndr, "reserved", r->reserved);
15049         ndr->depth--;
15050 }
15051
15052 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
15053 {
15054         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
15055 }
15056
15057 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
15058 {
15059         if (ndr_flags & NDR_SCALARS) {
15060                 int level = ndr_push_get_switch_value(ndr, r);
15061                 switch (level) {
15062                         case REG_NONE: {
15063                         break; }
15064
15065                         case REG_SZ: {
15066                                 {
15067                                         uint32_t _flags_save_string = ndr->flags;
15068                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15069                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
15070                                         ndr->flags = _flags_save_string;
15071                                 }
15072                         break; }
15073
15074                         case REG_BINARY: {
15075                                 {
15076                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15077                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15078                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
15079                                         ndr->flags = _flags_save_DATA_BLOB;
15080                                 }
15081                         break; }
15082
15083                         case REG_DWORD: {
15084                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
15085                         break; }
15086
15087                         case REG_MULTI_SZ: {
15088                                 {
15089                                         uint32_t _flags_save_string_array = ndr->flags;
15090                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15091                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
15092                                         ndr->flags = _flags_save_string_array;
15093                                 }
15094                         break; }
15095
15096                         default: {
15097                                 {
15098                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15099                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15100                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
15101                                         ndr->flags = _flags_save_DATA_BLOB;
15102                                 }
15103                         break; }
15104
15105                 }
15106         }
15107         if (ndr_flags & NDR_BUFFERS) {
15108                 int level = ndr_push_get_switch_value(ndr, r);
15109                 switch (level) {
15110                         case REG_NONE:
15111                         break;
15112
15113                         case REG_SZ:
15114                         break;
15115
15116                         case REG_BINARY:
15117                         break;
15118
15119                         case REG_DWORD:
15120                         break;
15121
15122                         case REG_MULTI_SZ:
15123                         break;
15124
15125                         default:
15126                         break;
15127
15128                 }
15129         }
15130         return NDR_ERR_SUCCESS;
15131 }
15132
15133 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
15134 {
15135         int level;
15136         level = ndr_pull_get_switch_value(ndr, r);
15137         if (ndr_flags & NDR_SCALARS) {
15138                 switch (level) {
15139                         case REG_NONE: {
15140                         break; }
15141
15142                         case REG_SZ: {
15143                                 {
15144                                         uint32_t _flags_save_string = ndr->flags;
15145                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15146                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
15147                                         ndr->flags = _flags_save_string;
15148                                 }
15149                         break; }
15150
15151                         case REG_BINARY: {
15152                                 {
15153                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15154                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15155                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
15156                                         ndr->flags = _flags_save_DATA_BLOB;
15157                                 }
15158                         break; }
15159
15160                         case REG_DWORD: {
15161                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
15162                         break; }
15163
15164                         case REG_MULTI_SZ: {
15165                                 {
15166                                         uint32_t _flags_save_string_array = ndr->flags;
15167                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15168                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
15169                                         ndr->flags = _flags_save_string_array;
15170                                 }
15171                         break; }
15172
15173                         default: {
15174                                 {
15175                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15176                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15177                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
15178                                         ndr->flags = _flags_save_DATA_BLOB;
15179                                 }
15180                         break; }
15181
15182                 }
15183         }
15184         if (ndr_flags & NDR_BUFFERS) {
15185                 switch (level) {
15186                         case REG_NONE:
15187                         break;
15188
15189                         case REG_SZ:
15190                         break;
15191
15192                         case REG_BINARY:
15193                         break;
15194
15195                         case REG_DWORD:
15196                         break;
15197
15198                         case REG_MULTI_SZ:
15199                         break;
15200
15201                         default:
15202                         break;
15203
15204                 }
15205         }
15206         return NDR_ERR_SUCCESS;
15207 }
15208
15209 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
15210 {
15211         int level;
15212         level = ndr_print_get_switch_value(ndr, r);
15213         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
15214         switch (level) {
15215                 case REG_NONE:
15216                 break;
15217
15218                 case REG_SZ:
15219                         ndr_print_string(ndr, "string", r->string);
15220                 break;
15221
15222                 case REG_BINARY:
15223                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
15224                 break;
15225
15226                 case REG_DWORD:
15227                         ndr_print_uint32(ndr, "value", r->value);
15228                 break;
15229
15230                 case REG_MULTI_SZ:
15231                         ndr_print_string_array(ndr, "string_array", r->string_array);
15232                 break;
15233
15234                 default:
15235                         ndr_print_DATA_BLOB(ndr, "data", r->data);
15236                 break;
15237
15238         }
15239 }
15240
15241 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15242 {
15243         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
15244 }
15245
15246 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
15247 {
15248         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15249         return NDR_ERR_SUCCESS;
15250 }
15251
15252 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
15253 {
15254         uint32_t v;
15255         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15256         *r = v;
15257         return NDR_ERR_SUCCESS;
15258 }
15259
15260 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
15261 {
15262         const char *val = NULL;
15263
15264         switch (r) {
15265                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
15266                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
15267                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
15268         }
15269         ndr_print_enum(ndr, name, "ENUM", val, r);
15270 }
15271
15272 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
15273 {
15274         if (ndr_flags & NDR_SCALARS) {
15275                 NDR_CHECK(ndr_push_align(ndr, 4));
15276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
15277                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
15278         }
15279         if (ndr_flags & NDR_BUFFERS) {
15280         }
15281         return NDR_ERR_SUCCESS;
15282 }
15283
15284 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
15285 {
15286         if (ndr_flags & NDR_SCALARS) {
15287                 NDR_CHECK(ndr_pull_align(ndr, 4));
15288                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
15289                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
15290         }
15291         if (ndr_flags & NDR_BUFFERS) {
15292         }
15293         return NDR_ERR_SUCCESS;
15294 }
15295
15296 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
15297 {
15298         ndr_print_struct(ndr, name, "spoolss_FormSize");
15299         ndr->depth++;
15300         ndr_print_uint32(ndr, "width", r->width);
15301         ndr_print_uint32(ndr, "height", r->height);
15302         ndr->depth--;
15303 }
15304
15305 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
15306 {
15307         if (ndr_flags & NDR_SCALARS) {
15308                 NDR_CHECK(ndr_push_align(ndr, 4));
15309                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
15310                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
15311                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
15312                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
15313         }
15314         if (ndr_flags & NDR_BUFFERS) {
15315         }
15316         return NDR_ERR_SUCCESS;
15317 }
15318
15319 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
15320 {
15321         if (ndr_flags & NDR_SCALARS) {
15322                 NDR_CHECK(ndr_pull_align(ndr, 4));
15323                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
15324                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
15325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
15326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
15327         }
15328         if (ndr_flags & NDR_BUFFERS) {
15329         }
15330         return NDR_ERR_SUCCESS;
15331 }
15332
15333 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
15334 {
15335         ndr_print_struct(ndr, name, "spoolss_FormArea");
15336         ndr->depth++;
15337         ndr_print_uint32(ndr, "left", r->left);
15338         ndr_print_uint32(ndr, "top", r->top);
15339         ndr_print_uint32(ndr, "right", r->right);
15340         ndr_print_uint32(ndr, "bottom", r->bottom);
15341         ndr->depth--;
15342 }
15343
15344 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
15345 {
15346         if (ndr_flags & NDR_SCALARS) {
15347                 NDR_CHECK(ndr_push_align(ndr, 4));
15348                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15349                 {
15350                         uint32_t _flags_save_string = ndr->flags;
15351                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15352                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
15353                         ndr->flags = _flags_save_string;
15354                 }
15355                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15356                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15357         }
15358         if (ndr_flags & NDR_BUFFERS) {
15359                 {
15360                         uint32_t _flags_save_string = ndr->flags;
15361                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15362                         if (r->form_name) {
15363                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
15364                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
15365                         }
15366                         ndr->flags = _flags_save_string;
15367                 }
15368         }
15369         return NDR_ERR_SUCCESS;
15370 }
15371
15372 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
15373 {
15374         uint32_t _ptr_form_name;
15375         TALLOC_CTX *_mem_save_form_name_0;
15376         if (ndr_flags & NDR_SCALARS) {
15377                 NDR_CHECK(ndr_pull_align(ndr, 4));
15378                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15379                 {
15380                         uint32_t _flags_save_string = ndr->flags;
15381                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15382                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15383                         if (_ptr_form_name) {
15384                                 NDR_PULL_ALLOC(ndr, r->form_name);
15385                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15386                         } else {
15387                                 r->form_name = NULL;
15388                         }
15389                         ndr->flags = _flags_save_string;
15390                 }
15391                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15392                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15393         }
15394         if (ndr_flags & NDR_BUFFERS) {
15395                 {
15396                         uint32_t _flags_save_string = ndr->flags;
15397                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15398                         if (r->form_name) {
15399                                 uint32_t _relative_save_offset;
15400                                 _relative_save_offset = ndr->offset;
15401                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15402                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15403                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15404                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15405                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15406                                 ndr->offset = _relative_save_offset;
15407                         }
15408                         ndr->flags = _flags_save_string;
15409                 }
15410         }
15411         return NDR_ERR_SUCCESS;
15412 }
15413
15414 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
15415 {
15416         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
15417         ndr->depth++;
15418         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15419         ndr_print_ptr(ndr, "form_name", r->form_name);
15420         ndr->depth++;
15421         if (r->form_name) {
15422                 ndr_print_string(ndr, "form_name", r->form_name);
15423         }
15424         ndr->depth--;
15425         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15426         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15427         ndr->depth--;
15428 }
15429
15430 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15431 {
15432         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
15433 }
15434
15435 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15436 {
15437         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15438         return NDR_ERR_SUCCESS;
15439 }
15440
15441 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15442 {
15443         uint32_t v;
15444         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15445         *r = v;
15446         return NDR_ERR_SUCCESS;
15447 }
15448
15449 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
15450 {
15451         ndr_print_uint32(ndr, name, r);
15452         ndr->depth++;
15453         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
15454         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
15455         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
15456         ndr->depth--;
15457 }
15458
15459 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
15460 {
15461         if (ndr_flags & NDR_SCALARS) {
15462                 NDR_CHECK(ndr_push_align(ndr, 4));
15463                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15464                 {
15465                         uint32_t _flags_save_string = ndr->flags;
15466                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15467                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
15468                         ndr->flags = _flags_save_string;
15469                 }
15470                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15471                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15472                 {
15473                         uint32_t _flags_save_string = ndr->flags;
15474                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15475                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
15476                         ndr->flags = _flags_save_string;
15477                 }
15478                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15479                 {
15480                         uint32_t _flags_save_string = ndr->flags;
15481                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15482                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
15483                         ndr->flags = _flags_save_string;
15484                 }
15485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15486                 {
15487                         uint32_t _flags_save_string = ndr->flags;
15488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15489                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
15490                         ndr->flags = _flags_save_string;
15491                 }
15492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15493         }
15494         if (ndr_flags & NDR_BUFFERS) {
15495                 {
15496                         uint32_t _flags_save_string = ndr->flags;
15497                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15498                         if (r->form_name) {
15499                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
15500                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
15501                         }
15502                         ndr->flags = _flags_save_string;
15503                 }
15504                 {
15505                         uint32_t _flags_save_string = ndr->flags;
15506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15507                         if (r->keyword) {
15508                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
15509                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
15510                         }
15511                         ndr->flags = _flags_save_string;
15512                 }
15513                 {
15514                         uint32_t _flags_save_string = ndr->flags;
15515                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15516                         if (r->mui_dll) {
15517                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
15518                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
15519                         }
15520                         ndr->flags = _flags_save_string;
15521                 }
15522                 {
15523                         uint32_t _flags_save_string = ndr->flags;
15524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15525                         if (r->display_name) {
15526                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
15527                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
15528                         }
15529                         ndr->flags = _flags_save_string;
15530                 }
15531         }
15532         return NDR_ERR_SUCCESS;
15533 }
15534
15535 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
15536 {
15537         uint32_t _ptr_form_name;
15538         TALLOC_CTX *_mem_save_form_name_0;
15539         uint32_t _ptr_keyword;
15540         TALLOC_CTX *_mem_save_keyword_0;
15541         uint32_t _ptr_mui_dll;
15542         TALLOC_CTX *_mem_save_mui_dll_0;
15543         uint32_t _ptr_display_name;
15544         TALLOC_CTX *_mem_save_display_name_0;
15545         if (ndr_flags & NDR_SCALARS) {
15546                 NDR_CHECK(ndr_pull_align(ndr, 4));
15547                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15548                 {
15549                         uint32_t _flags_save_string = ndr->flags;
15550                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15551                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15552                         if (_ptr_form_name) {
15553                                 NDR_PULL_ALLOC(ndr, r->form_name);
15554                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15555                         } else {
15556                                 r->form_name = NULL;
15557                         }
15558                         ndr->flags = _flags_save_string;
15559                 }
15560                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15561                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15562                 {
15563                         uint32_t _flags_save_string = ndr->flags;
15564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15565                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15566                         if (_ptr_keyword) {
15567                                 NDR_PULL_ALLOC(ndr, r->keyword);
15568                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
15569                         } else {
15570                                 r->keyword = NULL;
15571                         }
15572                         ndr->flags = _flags_save_string;
15573                 }
15574                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15575                 {
15576                         uint32_t _flags_save_string = ndr->flags;
15577                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15578                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15579                         if (_ptr_mui_dll) {
15580                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
15581                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
15582                         } else {
15583                                 r->mui_dll = NULL;
15584                         }
15585                         ndr->flags = _flags_save_string;
15586                 }
15587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15588                 {
15589                         uint32_t _flags_save_string = ndr->flags;
15590                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15591                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15592                         if (_ptr_display_name) {
15593                                 NDR_PULL_ALLOC(ndr, r->display_name);
15594                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
15595                         } else {
15596                                 r->display_name = NULL;
15597                         }
15598                         ndr->flags = _flags_save_string;
15599                 }
15600                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15601         }
15602         if (ndr_flags & NDR_BUFFERS) {
15603                 {
15604                         uint32_t _flags_save_string = ndr->flags;
15605                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15606                         if (r->form_name) {
15607                                 uint32_t _relative_save_offset;
15608                                 _relative_save_offset = ndr->offset;
15609                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15610                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15611                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15612                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15613                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15614                                 ndr->offset = _relative_save_offset;
15615                         }
15616                         ndr->flags = _flags_save_string;
15617                 }
15618                 {
15619                         uint32_t _flags_save_string = ndr->flags;
15620                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15621                         if (r->keyword) {
15622                                 uint32_t _relative_save_offset;
15623                                 _relative_save_offset = ndr->offset;
15624                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
15625                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15626                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15627                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
15628                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15629                                 ndr->offset = _relative_save_offset;
15630                         }
15631                         ndr->flags = _flags_save_string;
15632                 }
15633                 {
15634                         uint32_t _flags_save_string = ndr->flags;
15635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15636                         if (r->mui_dll) {
15637                                 uint32_t _relative_save_offset;
15638                                 _relative_save_offset = ndr->offset;
15639                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
15640                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15641                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15642                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
15643                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15644                                 ndr->offset = _relative_save_offset;
15645                         }
15646                         ndr->flags = _flags_save_string;
15647                 }
15648                 {
15649                         uint32_t _flags_save_string = ndr->flags;
15650                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15651                         if (r->display_name) {
15652                                 uint32_t _relative_save_offset;
15653                                 _relative_save_offset = ndr->offset;
15654                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
15655                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15656                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15657                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
15658                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15659                                 ndr->offset = _relative_save_offset;
15660                         }
15661                         ndr->flags = _flags_save_string;
15662                 }
15663         }
15664         return NDR_ERR_SUCCESS;
15665 }
15666
15667 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
15668 {
15669         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
15670         ndr->depth++;
15671         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15672         ndr_print_ptr(ndr, "form_name", r->form_name);
15673         ndr->depth++;
15674         if (r->form_name) {
15675                 ndr_print_string(ndr, "form_name", r->form_name);
15676         }
15677         ndr->depth--;
15678         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15679         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15680         ndr_print_ptr(ndr, "keyword", r->keyword);
15681         ndr->depth++;
15682         if (r->keyword) {
15683                 ndr_print_string(ndr, "keyword", r->keyword);
15684         }
15685         ndr->depth--;
15686         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15687         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15688         ndr->depth++;
15689         if (r->mui_dll) {
15690                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15691         }
15692         ndr->depth--;
15693         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15694         ndr_print_ptr(ndr, "display_name", r->display_name);
15695         ndr->depth++;
15696         if (r->display_name) {
15697                 ndr_print_string(ndr, "display_name", r->display_name);
15698         }
15699         ndr->depth--;
15700         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15701         ndr->depth--;
15702 }
15703
15704 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15705 {
15706         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
15707 }
15708
15709 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
15710 {
15711         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15712         if (ndr_flags & NDR_SCALARS) {
15713                 int level = ndr_push_get_switch_value(ndr, r);
15714                 switch (level) {
15715                         case 1: {
15716                                 NDR_CHECK(ndr_push_align(ndr, 4));
15717                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15718                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15719                         break; }
15720
15721                         case 2: {
15722                                 NDR_CHECK(ndr_push_align(ndr, 4));
15723                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15724                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15725                         break; }
15726
15727                         default: {
15728                         break; }
15729
15730                 }
15731         }
15732         if (ndr_flags & NDR_BUFFERS) {
15733                 int level = ndr_push_get_switch_value(ndr, r);
15734                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15735                 switch (level) {
15736                         case 1:
15737                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15738                         break;
15739
15740                         case 2:
15741                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15742                         break;
15743
15744                         default:
15745                         break;
15746
15747                 }
15748         }
15749         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15750         return NDR_ERR_SUCCESS;
15751 }
15752
15753 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
15754 {
15755         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15756         int level;
15757         level = ndr_pull_get_switch_value(ndr, r);
15758         if (ndr_flags & NDR_SCALARS) {
15759                 switch (level) {
15760                         case 1: {
15761                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15762                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15763                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15764                         break; }
15765
15766                         case 2: {
15767                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15768                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15769                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15770                         break; }
15771
15772                         default: {
15773                         break; }
15774
15775                 }
15776         }
15777         if (ndr_flags & NDR_BUFFERS) {
15778                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15779                 switch (level) {
15780                         case 1:
15781                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15782                         break;
15783
15784                         case 2:
15785                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15786                         break;
15787
15788                         default:
15789                         break;
15790
15791                 }
15792         }
15793         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15794         return NDR_ERR_SUCCESS;
15795 }
15796
15797 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
15798 {
15799         int level;
15800         level = ndr_print_get_switch_value(ndr, r);
15801         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
15802         switch (level) {
15803                 case 1:
15804                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
15805                 break;
15806
15807                 case 2:
15808                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
15809                 break;
15810
15811                 default:
15812                 break;
15813
15814         }
15815 }
15816
15817 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15818 {
15819         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
15820 }
15821
15822 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
15823 {
15824         if (ndr_flags & NDR_SCALARS) {
15825                 NDR_CHECK(ndr_push_align(ndr, 4));
15826                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15827                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15828                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15829                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15830         }
15831         if (ndr_flags & NDR_BUFFERS) {
15832                 if (r->form_name) {
15833                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15834                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15835                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15836                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15837                 }
15838         }
15839         return NDR_ERR_SUCCESS;
15840 }
15841
15842 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
15843 {
15844         uint32_t _ptr_form_name;
15845         TALLOC_CTX *_mem_save_form_name_0;
15846         if (ndr_flags & NDR_SCALARS) {
15847                 NDR_CHECK(ndr_pull_align(ndr, 4));
15848                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15849                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15850                 if (_ptr_form_name) {
15851                         NDR_PULL_ALLOC(ndr, r->form_name);
15852                 } else {
15853                         r->form_name = NULL;
15854                 }
15855                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15856                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15857         }
15858         if (ndr_flags & NDR_BUFFERS) {
15859                 if (r->form_name) {
15860                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15861                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15862                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15863                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15864                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15865                                 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));
15866                         }
15867                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15868                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15869                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15870                 }
15871         }
15872         return NDR_ERR_SUCCESS;
15873 }
15874
15875 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
15876 {
15877         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
15878         ndr->depth++;
15879         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15880         ndr_print_ptr(ndr, "form_name", r->form_name);
15881         ndr->depth++;
15882         if (r->form_name) {
15883                 ndr_print_string(ndr, "form_name", r->form_name);
15884         }
15885         ndr->depth--;
15886         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15887         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15888         ndr->depth--;
15889 }
15890
15891 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
15892 {
15893         if (ndr_flags & NDR_SCALARS) {
15894                 NDR_CHECK(ndr_push_align(ndr, 4));
15895                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15896                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15897                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15898                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15899                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
15900                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15901                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
15902                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15903                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
15904                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15905         }
15906         if (ndr_flags & NDR_BUFFERS) {
15907                 if (r->form_name) {
15908                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15909                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15910                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15911                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15912                 }
15913                 if (r->keyword) {
15914                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15915                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15916                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15917                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
15918                 }
15919                 if (r->mui_dll) {
15920                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15921                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15922                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15923                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15924                 }
15925                 if (r->display_name) {
15926                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15927                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15928                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15929                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15930                 }
15931         }
15932         return NDR_ERR_SUCCESS;
15933 }
15934
15935 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
15936 {
15937         uint32_t _ptr_form_name;
15938         TALLOC_CTX *_mem_save_form_name_0;
15939         uint32_t _ptr_keyword;
15940         TALLOC_CTX *_mem_save_keyword_0;
15941         uint32_t _ptr_mui_dll;
15942         TALLOC_CTX *_mem_save_mui_dll_0;
15943         uint32_t _ptr_display_name;
15944         TALLOC_CTX *_mem_save_display_name_0;
15945         if (ndr_flags & NDR_SCALARS) {
15946                 NDR_CHECK(ndr_pull_align(ndr, 4));
15947                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15948                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15949                 if (_ptr_form_name) {
15950                         NDR_PULL_ALLOC(ndr, r->form_name);
15951                 } else {
15952                         r->form_name = NULL;
15953                 }
15954                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15955                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15956                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15957                 if (_ptr_keyword) {
15958                         NDR_PULL_ALLOC(ndr, r->keyword);
15959                 } else {
15960                         r->keyword = NULL;
15961                 }
15962                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15963                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15964                 if (_ptr_mui_dll) {
15965                         NDR_PULL_ALLOC(ndr, r->mui_dll);
15966                 } else {
15967                         r->mui_dll = NULL;
15968                 }
15969                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15970                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15971                 if (_ptr_display_name) {
15972                         NDR_PULL_ALLOC(ndr, r->display_name);
15973                 } else {
15974                         r->display_name = NULL;
15975                 }
15976                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15977         }
15978         if (ndr_flags & NDR_BUFFERS) {
15979                 if (r->form_name) {
15980                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15981                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15982                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15983                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15984                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15985                                 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));
15986                         }
15987                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15988                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15989                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15990                 }
15991                 if (r->keyword) {
15992                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15993                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15994                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
15995                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
15996                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
15997                                 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));
15998                         }
15999                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
16000                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
16001                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16002                 }
16003                 if (r->mui_dll) {
16004                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16005                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16006                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
16007                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
16008                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
16009                                 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));
16010                         }
16011                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
16012                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
16013                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16014                 }
16015                 if (r->display_name) {
16016                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16017                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16018                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
16019                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
16020                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
16021                                 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));
16022                         }
16023                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
16024                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
16025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16026                 }
16027         }
16028         return NDR_ERR_SUCCESS;
16029 }
16030
16031 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
16032 {
16033         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
16034         ndr->depth++;
16035         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16036         ndr_print_ptr(ndr, "form_name", r->form_name);
16037         ndr->depth++;
16038         if (r->form_name) {
16039                 ndr_print_string(ndr, "form_name", r->form_name);
16040         }
16041         ndr->depth--;
16042         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16043         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16044         ndr_print_ptr(ndr, "keyword", r->keyword);
16045         ndr->depth++;
16046         if (r->keyword) {
16047                 ndr_print_string(ndr, "keyword", r->keyword);
16048         }
16049         ndr->depth--;
16050         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16051         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16052         ndr->depth++;
16053         if (r->mui_dll) {
16054                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16055         }
16056         ndr->depth--;
16057         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16058         ndr_print_ptr(ndr, "display_name", r->display_name);
16059         ndr->depth++;
16060         if (r->display_name) {
16061                 ndr_print_string(ndr, "display_name", r->display_name);
16062         }
16063         ndr->depth--;
16064         ndr_print_uint32(ndr, "lang_id", r->lang_id);
16065         ndr->depth--;
16066 }
16067
16068 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
16069 {
16070         if (ndr_flags & NDR_SCALARS) {
16071                 int level = ndr_push_get_switch_value(ndr, r);
16072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
16073                 switch (level) {
16074                         case 1: {
16075                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
16076                         break; }
16077
16078                         case 2: {
16079                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
16080                         break; }
16081
16082                         default:
16083                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
16084                 }
16085         }
16086         if (ndr_flags & NDR_BUFFERS) {
16087                 int level = ndr_push_get_switch_value(ndr, r);
16088                 switch (level) {
16089                         case 1:
16090                                 if (r->info1) {
16091                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16092                                 }
16093                         break;
16094
16095                         case 2:
16096                                 if (r->info2) {
16097                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16098                                 }
16099                         break;
16100
16101                         default:
16102                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
16103                 }
16104         }
16105         return NDR_ERR_SUCCESS;
16106 }
16107
16108 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
16109 {
16110         int level;
16111         uint32_t _level;
16112         TALLOC_CTX *_mem_save_info1_0;
16113         TALLOC_CTX *_mem_save_info2_0;
16114         level = ndr_pull_get_switch_value(ndr, r);
16115         if (ndr_flags & NDR_SCALARS) {
16116                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
16117                 if (_level != level) {
16118                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
16119                 }
16120                 switch (level) {
16121                         case 1: {
16122                                 uint32_t _ptr_info1;
16123                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
16124                                 if (_ptr_info1) {
16125                                         NDR_PULL_ALLOC(ndr, r->info1);
16126                                 } else {
16127                                         r->info1 = NULL;
16128                                 }
16129                         break; }
16130
16131                         case 2: {
16132                                 uint32_t _ptr_info2;
16133                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
16134                                 if (_ptr_info2) {
16135                                         NDR_PULL_ALLOC(ndr, r->info2);
16136                                 } else {
16137                                         r->info2 = NULL;
16138                                 }
16139                         break; }
16140
16141                         default:
16142                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
16143                 }
16144         }
16145         if (ndr_flags & NDR_BUFFERS) {
16146                 switch (level) {
16147                         case 1:
16148                                 if (r->info1) {
16149                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
16150                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
16151                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16152                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
16153                                 }
16154                         break;
16155
16156                         case 2:
16157                                 if (r->info2) {
16158                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
16159                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
16160                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16161                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
16162                                 }
16163                         break;
16164
16165                         default:
16166                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
16167                 }
16168         }
16169         return NDR_ERR_SUCCESS;
16170 }
16171
16172 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
16173 {
16174         int level;
16175         level = ndr_print_get_switch_value(ndr, r);
16176         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
16177         switch (level) {
16178                 case 1:
16179                         ndr_print_ptr(ndr, "info1", r->info1);
16180                         ndr->depth++;
16181                         if (r->info1) {
16182                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
16183                         }
16184                         ndr->depth--;
16185                 break;
16186
16187                 case 2:
16188                         ndr_print_ptr(ndr, "info2", r->info2);
16189                         ndr->depth++;
16190                         if (r->info2) {
16191                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
16192                         }
16193                         ndr->depth--;
16194                 break;
16195
16196                 default:
16197                         ndr_print_bad_level(ndr, name, level);
16198         }
16199 }
16200
16201 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
16202 {
16203         if (ndr_flags & NDR_SCALARS) {
16204                 NDR_CHECK(ndr_push_align(ndr, 4));
16205                 {
16206                         uint32_t _flags_save_string = ndr->flags;
16207                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16208                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16209                         ndr->flags = _flags_save_string;
16210                 }
16211         }
16212         if (ndr_flags & NDR_BUFFERS) {
16213                 {
16214                         uint32_t _flags_save_string = ndr->flags;
16215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16216                         if (r->port_name) {
16217                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16218                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16219                         }
16220                         ndr->flags = _flags_save_string;
16221                 }
16222         }
16223         return NDR_ERR_SUCCESS;
16224 }
16225
16226 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
16227 {
16228         uint32_t _ptr_port_name;
16229         TALLOC_CTX *_mem_save_port_name_0;
16230         if (ndr_flags & NDR_SCALARS) {
16231                 NDR_CHECK(ndr_pull_align(ndr, 4));
16232                 {
16233                         uint32_t _flags_save_string = ndr->flags;
16234                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16235                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16236                         if (_ptr_port_name) {
16237                                 NDR_PULL_ALLOC(ndr, r->port_name);
16238                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16239                         } else {
16240                                 r->port_name = NULL;
16241                         }
16242                         ndr->flags = _flags_save_string;
16243                 }
16244         }
16245         if (ndr_flags & NDR_BUFFERS) {
16246                 {
16247                         uint32_t _flags_save_string = ndr->flags;
16248                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16249                         if (r->port_name) {
16250                                 uint32_t _relative_save_offset;
16251                                 _relative_save_offset = ndr->offset;
16252                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16253                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16254                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16255                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16256                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16257                                 ndr->offset = _relative_save_offset;
16258                         }
16259                         ndr->flags = _flags_save_string;
16260                 }
16261         }
16262         return NDR_ERR_SUCCESS;
16263 }
16264
16265 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
16266 {
16267         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
16268         ndr->depth++;
16269         ndr_print_ptr(ndr, "port_name", r->port_name);
16270         ndr->depth++;
16271         if (r->port_name) {
16272                 ndr_print_string(ndr, "port_name", r->port_name);
16273         }
16274         ndr->depth--;
16275         ndr->depth--;
16276 }
16277
16278 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16279 {
16280         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
16281 }
16282
16283 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16284 {
16285         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16286         return NDR_ERR_SUCCESS;
16287 }
16288
16289 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16290 {
16291         uint32_t v;
16292         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16293         *r = v;
16294         return NDR_ERR_SUCCESS;
16295 }
16296
16297 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
16298 {
16299         ndr_print_uint32(ndr, name, r);
16300         ndr->depth++;
16301         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
16302         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
16303         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
16304         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
16305         ndr->depth--;
16306 }
16307
16308 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
16309 {
16310         if (ndr_flags & NDR_SCALARS) {
16311                 NDR_CHECK(ndr_push_align(ndr, 4));
16312                 {
16313                         uint32_t _flags_save_string = ndr->flags;
16314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16315                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16316                         ndr->flags = _flags_save_string;
16317                 }
16318                 {
16319                         uint32_t _flags_save_string = ndr->flags;
16320                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16321                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16322                         ndr->flags = _flags_save_string;
16323                 }
16324                 {
16325                         uint32_t _flags_save_string = ndr->flags;
16326                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16327                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
16328                         ndr->flags = _flags_save_string;
16329                 }
16330                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
16331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
16332         }
16333         if (ndr_flags & NDR_BUFFERS) {
16334                 {
16335                         uint32_t _flags_save_string = ndr->flags;
16336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16337                         if (r->port_name) {
16338                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16339                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16340                         }
16341                         ndr->flags = _flags_save_string;
16342                 }
16343                 {
16344                         uint32_t _flags_save_string = ndr->flags;
16345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16346                         if (r->monitor_name) {
16347                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16348                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16349                         }
16350                         ndr->flags = _flags_save_string;
16351                 }
16352                 {
16353                         uint32_t _flags_save_string = ndr->flags;
16354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16355                         if (r->description) {
16356                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
16357                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
16358                         }
16359                         ndr->flags = _flags_save_string;
16360                 }
16361         }
16362         return NDR_ERR_SUCCESS;
16363 }
16364
16365 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
16366 {
16367         uint32_t _ptr_port_name;
16368         TALLOC_CTX *_mem_save_port_name_0;
16369         uint32_t _ptr_monitor_name;
16370         TALLOC_CTX *_mem_save_monitor_name_0;
16371         uint32_t _ptr_description;
16372         TALLOC_CTX *_mem_save_description_0;
16373         if (ndr_flags & NDR_SCALARS) {
16374                 NDR_CHECK(ndr_pull_align(ndr, 4));
16375                 {
16376                         uint32_t _flags_save_string = ndr->flags;
16377                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16378                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16379                         if (_ptr_port_name) {
16380                                 NDR_PULL_ALLOC(ndr, r->port_name);
16381                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16382                         } else {
16383                                 r->port_name = NULL;
16384                         }
16385                         ndr->flags = _flags_save_string;
16386                 }
16387                 {
16388                         uint32_t _flags_save_string = ndr->flags;
16389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16390                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16391                         if (_ptr_monitor_name) {
16392                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16393                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16394                         } else {
16395                                 r->monitor_name = NULL;
16396                         }
16397                         ndr->flags = _flags_save_string;
16398                 }
16399                 {
16400                         uint32_t _flags_save_string = ndr->flags;
16401                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16402                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
16403                         if (_ptr_description) {
16404                                 NDR_PULL_ALLOC(ndr, r->description);
16405                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
16406                         } else {
16407                                 r->description = NULL;
16408                         }
16409                         ndr->flags = _flags_save_string;
16410                 }
16411                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
16412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
16413         }
16414         if (ndr_flags & NDR_BUFFERS) {
16415                 {
16416                         uint32_t _flags_save_string = ndr->flags;
16417                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16418                         if (r->port_name) {
16419                                 uint32_t _relative_save_offset;
16420                                 _relative_save_offset = ndr->offset;
16421                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16422                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16423                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16424                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16425                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16426                                 ndr->offset = _relative_save_offset;
16427                         }
16428                         ndr->flags = _flags_save_string;
16429                 }
16430                 {
16431                         uint32_t _flags_save_string = ndr->flags;
16432                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16433                         if (r->monitor_name) {
16434                                 uint32_t _relative_save_offset;
16435                                 _relative_save_offset = ndr->offset;
16436                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16437                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16438                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16439                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16440                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16441                                 ndr->offset = _relative_save_offset;
16442                         }
16443                         ndr->flags = _flags_save_string;
16444                 }
16445                 {
16446                         uint32_t _flags_save_string = ndr->flags;
16447                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16448                         if (r->description) {
16449                                 uint32_t _relative_save_offset;
16450                                 _relative_save_offset = ndr->offset;
16451                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
16452                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
16453                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
16454                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
16455                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
16456                                 ndr->offset = _relative_save_offset;
16457                         }
16458                         ndr->flags = _flags_save_string;
16459                 }
16460         }
16461         return NDR_ERR_SUCCESS;
16462 }
16463
16464 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
16465 {
16466         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
16467         ndr->depth++;
16468         ndr_print_ptr(ndr, "port_name", r->port_name);
16469         ndr->depth++;
16470         if (r->port_name) {
16471                 ndr_print_string(ndr, "port_name", r->port_name);
16472         }
16473         ndr->depth--;
16474         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16475         ndr->depth++;
16476         if (r->monitor_name) {
16477                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16478         }
16479         ndr->depth--;
16480         ndr_print_ptr(ndr, "description", r->description);
16481         ndr->depth++;
16482         if (r->description) {
16483                 ndr_print_string(ndr, "description", r->description);
16484         }
16485         ndr->depth--;
16486         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
16487         ndr_print_uint32(ndr, "reserved", r->reserved);
16488         ndr->depth--;
16489 }
16490
16491 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16492 {
16493         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
16494 }
16495
16496 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
16497 {
16498         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16499         return NDR_ERR_SUCCESS;
16500 }
16501
16502 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
16503 {
16504         uint32_t v;
16505         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16506         *r = v;
16507         return NDR_ERR_SUCCESS;
16508 }
16509
16510 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
16511 {
16512         const char *val = NULL;
16513
16514         switch (r) {
16515                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
16516                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
16517                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
16518                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
16519                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
16520                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
16521                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
16522                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
16523                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
16524                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
16525                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
16526                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
16527                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
16528         }
16529         ndr_print_enum(ndr, name, "ENUM", val, r);
16530 }
16531
16532 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
16533 {
16534         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16535         return NDR_ERR_SUCCESS;
16536 }
16537
16538 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
16539 {
16540         uint32_t v;
16541         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16542         *r = v;
16543         return NDR_ERR_SUCCESS;
16544 }
16545
16546 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
16547 {
16548         const char *val = NULL;
16549
16550         switch (r) {
16551                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
16552                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
16553                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
16554         }
16555         ndr_print_enum(ndr, name, "ENUM", val, r);
16556 }
16557
16558 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
16559 {
16560         if (ndr_flags & NDR_SCALARS) {
16561                 NDR_CHECK(ndr_push_align(ndr, 4));
16562                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
16563                 {
16564                         uint32_t _flags_save_string = ndr->flags;
16565                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16566                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
16567                         ndr->flags = _flags_save_string;
16568                 }
16569                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
16570         }
16571         if (ndr_flags & NDR_BUFFERS) {
16572                 {
16573                         uint32_t _flags_save_string = ndr->flags;
16574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16575                         if (r->status_string) {
16576                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
16577                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
16578                         }
16579                         ndr->flags = _flags_save_string;
16580                 }
16581         }
16582         return NDR_ERR_SUCCESS;
16583 }
16584
16585 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
16586 {
16587         uint32_t _ptr_status_string;
16588         TALLOC_CTX *_mem_save_status_string_0;
16589         if (ndr_flags & NDR_SCALARS) {
16590                 NDR_CHECK(ndr_pull_align(ndr, 4));
16591                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
16592                 {
16593                         uint32_t _flags_save_string = ndr->flags;
16594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16595                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
16596                         if (_ptr_status_string) {
16597                                 NDR_PULL_ALLOC(ndr, r->status_string);
16598                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
16599                         } else {
16600                                 r->status_string = NULL;
16601                         }
16602                         ndr->flags = _flags_save_string;
16603                 }
16604                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
16605         }
16606         if (ndr_flags & NDR_BUFFERS) {
16607                 {
16608                         uint32_t _flags_save_string = ndr->flags;
16609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16610                         if (r->status_string) {
16611                                 uint32_t _relative_save_offset;
16612                                 _relative_save_offset = ndr->offset;
16613                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
16614                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
16615                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
16616                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
16617                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
16618                                 ndr->offset = _relative_save_offset;
16619                         }
16620                         ndr->flags = _flags_save_string;
16621                 }
16622         }
16623         return NDR_ERR_SUCCESS;
16624 }
16625
16626 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
16627 {
16628         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
16629         ndr->depth++;
16630         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
16631         ndr_print_ptr(ndr, "status_string", r->status_string);
16632         ndr->depth++;
16633         if (r->status_string) {
16634                 ndr_print_string(ndr, "status_string", r->status_string);
16635         }
16636         ndr->depth--;
16637         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
16638         ndr->depth--;
16639 }
16640
16641 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
16642 {
16643         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
16644 }
16645
16646 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
16647 {
16648         if (ndr_flags & NDR_SCALARS) {
16649                 NDR_CHECK(ndr_push_align(ndr, 4));
16650                 {
16651                         uint32_t _flags_save_string = ndr->flags;
16652                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16653                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16654                         ndr->flags = _flags_save_string;
16655                 }
16656                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
16657         }
16658         if (ndr_flags & NDR_BUFFERS) {
16659                 {
16660                         uint32_t _flags_save_string = ndr->flags;
16661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16662                         if (r->port_name) {
16663                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16664                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16665                         }
16666                         ndr->flags = _flags_save_string;
16667                 }
16668         }
16669         return NDR_ERR_SUCCESS;
16670 }
16671
16672 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
16673 {
16674         uint32_t _ptr_port_name;
16675         TALLOC_CTX *_mem_save_port_name_0;
16676         if (ndr_flags & NDR_SCALARS) {
16677                 NDR_CHECK(ndr_pull_align(ndr, 4));
16678                 {
16679                         uint32_t _flags_save_string = ndr->flags;
16680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16681                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16682                         if (_ptr_port_name) {
16683                                 NDR_PULL_ALLOC(ndr, r->port_name);
16684                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16685                         } else {
16686                                 r->port_name = NULL;
16687                         }
16688                         ndr->flags = _flags_save_string;
16689                 }
16690                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
16691         }
16692         if (ndr_flags & NDR_BUFFERS) {
16693                 {
16694                         uint32_t _flags_save_string = ndr->flags;
16695                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16696                         if (r->port_name) {
16697                                 uint32_t _relative_save_offset;
16698                                 _relative_save_offset = ndr->offset;
16699                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16700                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16701                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16702                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16703                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16704                                 ndr->offset = _relative_save_offset;
16705                         }
16706                         ndr->flags = _flags_save_string;
16707                 }
16708         }
16709         return NDR_ERR_SUCCESS;
16710 }
16711
16712 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
16713 {
16714         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
16715         ndr->depth++;
16716         ndr_print_ptr(ndr, "port_name", r->port_name);
16717         ndr->depth++;
16718         if (r->port_name) {
16719                 ndr_print_string(ndr, "port_name", r->port_name);
16720         }
16721         ndr->depth--;
16722         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
16723         ndr->depth--;
16724 }
16725
16726 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
16727 {
16728         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
16729 }
16730
16731 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
16732 {
16733         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16734         if (ndr_flags & NDR_SCALARS) {
16735                 int level = ndr_push_get_switch_value(ndr, r);
16736                 switch (level) {
16737                         case 1: {
16738                                 NDR_CHECK(ndr_push_align(ndr, 4));
16739                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16740                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16741                         break; }
16742
16743                         case 2: {
16744                                 NDR_CHECK(ndr_push_align(ndr, 4));
16745                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16746                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16747                         break; }
16748
16749                         case 3: {
16750                                 NDR_CHECK(ndr_push_align(ndr, 4));
16751                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16752                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16753                         break; }
16754
16755                         case 0xff: {
16756                                 NDR_CHECK(ndr_push_align(ndr, 4));
16757                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16758                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16759                         break; }
16760
16761                         default: {
16762                         break; }
16763
16764                 }
16765         }
16766         if (ndr_flags & NDR_BUFFERS) {
16767                 int level = ndr_push_get_switch_value(ndr, r);
16768                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16769                 switch (level) {
16770                         case 1:
16771                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16772                         break;
16773
16774                         case 2:
16775                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16776                         break;
16777
16778                         case 3:
16779                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16780                         break;
16781
16782                         case 0xff:
16783                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16784                         break;
16785
16786                         default:
16787                         break;
16788
16789                 }
16790         }
16791         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16792         return NDR_ERR_SUCCESS;
16793 }
16794
16795 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
16796 {
16797         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16798         int level;
16799         level = ndr_pull_get_switch_value(ndr, r);
16800         if (ndr_flags & NDR_SCALARS) {
16801                 switch (level) {
16802                         case 1: {
16803                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16804                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16805                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16806                         break; }
16807
16808                         case 2: {
16809                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16810                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16811                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16812                         break; }
16813
16814                         case 3: {
16815                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16816                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16817                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16818                         break; }
16819
16820                         case 0xff: {
16821                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16822                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16823                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16824                         break; }
16825
16826                         default: {
16827                         break; }
16828
16829                 }
16830         }
16831         if (ndr_flags & NDR_BUFFERS) {
16832                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16833                 switch (level) {
16834                         case 1:
16835                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16836                         break;
16837
16838                         case 2:
16839                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16840                         break;
16841
16842                         case 3:
16843                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16844                         break;
16845
16846                         case 0xff:
16847                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16848                         break;
16849
16850                         default:
16851                         break;
16852
16853                 }
16854         }
16855         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16856         return NDR_ERR_SUCCESS;
16857 }
16858
16859 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
16860 {
16861         int level;
16862         level = ndr_print_get_switch_value(ndr, r);
16863         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
16864         switch (level) {
16865                 case 1:
16866                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
16867                 break;
16868
16869                 case 2:
16870                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
16871                 break;
16872
16873                 case 3:
16874                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
16875                 break;
16876
16877                 case 0xff:
16878                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
16879                 break;
16880
16881                 default:
16882                 break;
16883
16884         }
16885 }
16886
16887 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
16888 {
16889         if (ndr_flags & NDR_SCALARS) {
16890                 NDR_CHECK(ndr_push_align(ndr, 4));
16891                 {
16892                         uint32_t _flags_save_string = ndr->flags;
16893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16894                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16895                         ndr->flags = _flags_save_string;
16896                 }
16897         }
16898         if (ndr_flags & NDR_BUFFERS) {
16899                 {
16900                         uint32_t _flags_save_string = ndr->flags;
16901                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16902                         if (r->monitor_name) {
16903                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16904                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16905                         }
16906                         ndr->flags = _flags_save_string;
16907                 }
16908         }
16909         return NDR_ERR_SUCCESS;
16910 }
16911
16912 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
16913 {
16914         uint32_t _ptr_monitor_name;
16915         TALLOC_CTX *_mem_save_monitor_name_0;
16916         if (ndr_flags & NDR_SCALARS) {
16917                 NDR_CHECK(ndr_pull_align(ndr, 4));
16918                 {
16919                         uint32_t _flags_save_string = ndr->flags;
16920                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16921                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16922                         if (_ptr_monitor_name) {
16923                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16924                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16925                         } else {
16926                                 r->monitor_name = NULL;
16927                         }
16928                         ndr->flags = _flags_save_string;
16929                 }
16930         }
16931         if (ndr_flags & NDR_BUFFERS) {
16932                 {
16933                         uint32_t _flags_save_string = ndr->flags;
16934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16935                         if (r->monitor_name) {
16936                                 uint32_t _relative_save_offset;
16937                                 _relative_save_offset = ndr->offset;
16938                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16939                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16940                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16941                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16942                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16943                                 ndr->offset = _relative_save_offset;
16944                         }
16945                         ndr->flags = _flags_save_string;
16946                 }
16947         }
16948         return NDR_ERR_SUCCESS;
16949 }
16950
16951 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
16952 {
16953         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
16954         ndr->depth++;
16955         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16956         ndr->depth++;
16957         if (r->monitor_name) {
16958                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16959         }
16960         ndr->depth--;
16961         ndr->depth--;
16962 }
16963
16964 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16965 {
16966         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
16967 }
16968
16969 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
16970 {
16971         if (ndr_flags & NDR_SCALARS) {
16972                 NDR_CHECK(ndr_push_align(ndr, 4));
16973                 {
16974                         uint32_t _flags_save_string = ndr->flags;
16975                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16976                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16977                         ndr->flags = _flags_save_string;
16978                 }
16979                 {
16980                         uint32_t _flags_save_string = ndr->flags;
16981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16982                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
16983                         ndr->flags = _flags_save_string;
16984                 }
16985                 {
16986                         uint32_t _flags_save_string = ndr->flags;
16987                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16988                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
16989                         ndr->flags = _flags_save_string;
16990                 }
16991         }
16992         if (ndr_flags & NDR_BUFFERS) {
16993                 {
16994                         uint32_t _flags_save_string = ndr->flags;
16995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16996                         if (r->monitor_name) {
16997                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16998                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16999                         }
17000                         ndr->flags = _flags_save_string;
17001                 }
17002                 {
17003                         uint32_t _flags_save_string = ndr->flags;
17004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17005                         if (r->environment) {
17006                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
17007                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
17008                         }
17009                         ndr->flags = _flags_save_string;
17010                 }
17011                 {
17012                         uint32_t _flags_save_string = ndr->flags;
17013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17014                         if (r->dll_name) {
17015                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
17016                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
17017                         }
17018                         ndr->flags = _flags_save_string;
17019                 }
17020         }
17021         return NDR_ERR_SUCCESS;
17022 }
17023
17024 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
17025 {
17026         uint32_t _ptr_monitor_name;
17027         TALLOC_CTX *_mem_save_monitor_name_0;
17028         uint32_t _ptr_environment;
17029         TALLOC_CTX *_mem_save_environment_0;
17030         uint32_t _ptr_dll_name;
17031         TALLOC_CTX *_mem_save_dll_name_0;
17032         if (ndr_flags & NDR_SCALARS) {
17033                 NDR_CHECK(ndr_pull_align(ndr, 4));
17034                 {
17035                         uint32_t _flags_save_string = ndr->flags;
17036                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17037                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17038                         if (_ptr_monitor_name) {
17039                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17040                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17041                         } else {
17042                                 r->monitor_name = NULL;
17043                         }
17044                         ndr->flags = _flags_save_string;
17045                 }
17046                 {
17047                         uint32_t _flags_save_string = ndr->flags;
17048                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17049                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
17050                         if (_ptr_environment) {
17051                                 NDR_PULL_ALLOC(ndr, r->environment);
17052                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
17053                         } else {
17054                                 r->environment = NULL;
17055                         }
17056                         ndr->flags = _flags_save_string;
17057                 }
17058                 {
17059                         uint32_t _flags_save_string = ndr->flags;
17060                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17061                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
17062                         if (_ptr_dll_name) {
17063                                 NDR_PULL_ALLOC(ndr, r->dll_name);
17064                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
17065                         } else {
17066                                 r->dll_name = NULL;
17067                         }
17068                         ndr->flags = _flags_save_string;
17069                 }
17070         }
17071         if (ndr_flags & NDR_BUFFERS) {
17072                 {
17073                         uint32_t _flags_save_string = ndr->flags;
17074                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17075                         if (r->monitor_name) {
17076                                 uint32_t _relative_save_offset;
17077                                 _relative_save_offset = ndr->offset;
17078                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17079                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17080                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17081                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17082                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17083                                 ndr->offset = _relative_save_offset;
17084                         }
17085                         ndr->flags = _flags_save_string;
17086                 }
17087                 {
17088                         uint32_t _flags_save_string = ndr->flags;
17089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17090                         if (r->environment) {
17091                                 uint32_t _relative_save_offset;
17092                                 _relative_save_offset = ndr->offset;
17093                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
17094                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
17095                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
17096                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
17097                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
17098                                 ndr->offset = _relative_save_offset;
17099                         }
17100                         ndr->flags = _flags_save_string;
17101                 }
17102                 {
17103                         uint32_t _flags_save_string = ndr->flags;
17104                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17105                         if (r->dll_name) {
17106                                 uint32_t _relative_save_offset;
17107                                 _relative_save_offset = ndr->offset;
17108                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
17109                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17110                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
17111                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
17112                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
17113                                 ndr->offset = _relative_save_offset;
17114                         }
17115                         ndr->flags = _flags_save_string;
17116                 }
17117         }
17118         return NDR_ERR_SUCCESS;
17119 }
17120
17121 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
17122 {
17123         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
17124         ndr->depth++;
17125         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17126         ndr->depth++;
17127         if (r->monitor_name) {
17128                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17129         }
17130         ndr->depth--;
17131         ndr_print_ptr(ndr, "environment", r->environment);
17132         ndr->depth++;
17133         if (r->environment) {
17134                 ndr_print_string(ndr, "environment", r->environment);
17135         }
17136         ndr->depth--;
17137         ndr_print_ptr(ndr, "dll_name", r->dll_name);
17138         ndr->depth++;
17139         if (r->dll_name) {
17140                 ndr_print_string(ndr, "dll_name", r->dll_name);
17141         }
17142         ndr->depth--;
17143         ndr->depth--;
17144 }
17145
17146 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17147 {
17148         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
17149 }
17150
17151 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
17152 {
17153         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17154         if (ndr_flags & NDR_SCALARS) {
17155                 int level = ndr_push_get_switch_value(ndr, r);
17156                 switch (level) {
17157                         case 1: {
17158                                 NDR_CHECK(ndr_push_align(ndr, 4));
17159                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17160                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17161                         break; }
17162
17163                         case 2: {
17164                                 NDR_CHECK(ndr_push_align(ndr, 4));
17165                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17166                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17167                         break; }
17168
17169                         default: {
17170                         break; }
17171
17172                 }
17173         }
17174         if (ndr_flags & NDR_BUFFERS) {
17175                 int level = ndr_push_get_switch_value(ndr, r);
17176                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17177                 switch (level) {
17178                         case 1:
17179                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
17180                         break;
17181
17182                         case 2:
17183                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
17184                         break;
17185
17186                         default:
17187                         break;
17188
17189                 }
17190         }
17191         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17192         return NDR_ERR_SUCCESS;
17193 }
17194
17195 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
17196 {
17197         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17198         int level;
17199         level = ndr_pull_get_switch_value(ndr, r);
17200         if (ndr_flags & NDR_SCALARS) {
17201                 switch (level) {
17202                         case 1: {
17203                                 NDR_CHECK(ndr_pull_align(ndr, 4));
17204                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17205                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17206                         break; }
17207
17208                         case 2: {
17209                                 NDR_CHECK(ndr_pull_align(ndr, 4));
17210                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17211                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17212                         break; }
17213
17214                         default: {
17215                         break; }
17216
17217                 }
17218         }
17219         if (ndr_flags & NDR_BUFFERS) {
17220                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17221                 switch (level) {
17222                         case 1:
17223                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
17224                         break;
17225
17226                         case 2:
17227                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
17228                         break;
17229
17230                         default:
17231                         break;
17232
17233                 }
17234         }
17235         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17236         return NDR_ERR_SUCCESS;
17237 }
17238
17239 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
17240 {
17241         int level;
17242         level = ndr_print_get_switch_value(ndr, r);
17243         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
17244         switch (level) {
17245                 case 1:
17246                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
17247                 break;
17248
17249                 case 2:
17250                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
17251                 break;
17252
17253                 default:
17254                 break;
17255
17256         }
17257 }
17258
17259 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
17260 {
17261         if (ndr_flags & NDR_SCALARS) {
17262                 NDR_CHECK(ndr_push_align(ndr, 4));
17263                 {
17264                         uint32_t _flags_save_string = ndr->flags;
17265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17266                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
17267                         ndr->flags = _flags_save_string;
17268                 }
17269         }
17270         if (ndr_flags & NDR_BUFFERS) {
17271                 {
17272                         uint32_t _flags_save_string = ndr->flags;
17273                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17274                         if (r->name_array) {
17275                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name_array));
17276                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
17277                         }
17278                         ndr->flags = _flags_save_string;
17279                 }
17280         }
17281         return NDR_ERR_SUCCESS;
17282 }
17283
17284 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
17285 {
17286         uint32_t _ptr_name_array;
17287         TALLOC_CTX *_mem_save_name_array_0;
17288         if (ndr_flags & NDR_SCALARS) {
17289                 NDR_CHECK(ndr_pull_align(ndr, 4));
17290                 {
17291                         uint32_t _flags_save_string = ndr->flags;
17292                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17293                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
17294                         if (_ptr_name_array) {
17295                                 NDR_PULL_ALLOC(ndr, r->name_array);
17296                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
17297                         } else {
17298                                 r->name_array = NULL;
17299                         }
17300                         ndr->flags = _flags_save_string;
17301                 }
17302         }
17303         if (ndr_flags & NDR_BUFFERS) {
17304                 {
17305                         uint32_t _flags_save_string = ndr->flags;
17306                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17307                         if (r->name_array) {
17308                                 uint32_t _relative_save_offset;
17309                                 _relative_save_offset = ndr->offset;
17310                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
17311                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
17312                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
17313                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
17314                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
17315                                 ndr->offset = _relative_save_offset;
17316                         }
17317                         ndr->flags = _flags_save_string;
17318                 }
17319         }
17320         return NDR_ERR_SUCCESS;
17321 }
17322
17323 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
17324 {
17325         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
17326         ndr->depth++;
17327         ndr_print_ptr(ndr, "name_array", r->name_array);
17328         ndr->depth++;
17329         if (r->name_array) {
17330                 ndr_print_string(ndr, "name_array", r->name_array);
17331         }
17332         ndr->depth--;
17333         ndr->depth--;
17334 }
17335
17336 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17337 {
17338         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
17339 }
17340
17341 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
17342 {
17343         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17344         if (ndr_flags & NDR_SCALARS) {
17345                 int level = ndr_push_get_switch_value(ndr, r);
17346                 switch (level) {
17347                         case 1: {
17348                                 NDR_CHECK(ndr_push_align(ndr, 4));
17349                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17350                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
17351                         break; }
17352
17353                         default: {
17354                         break; }
17355
17356                 }
17357         }
17358         if (ndr_flags & NDR_BUFFERS) {
17359                 int level = ndr_push_get_switch_value(ndr, r);
17360                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17361                 switch (level) {
17362                         case 1:
17363                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
17364                         break;
17365
17366                         default:
17367                         break;
17368
17369                 }
17370         }
17371         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17372         return NDR_ERR_SUCCESS;
17373 }
17374
17375 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
17376 {
17377         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17378         int level;
17379         level = ndr_pull_get_switch_value(ndr, r);
17380         if (ndr_flags & NDR_SCALARS) {
17381                 switch (level) {
17382                         case 1: {
17383                                 NDR_CHECK(ndr_pull_align(ndr, 4));
17384                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17385                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
17386                         break; }
17387
17388                         default: {
17389                         break; }
17390
17391                 }
17392         }
17393         if (ndr_flags & NDR_BUFFERS) {
17394                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17395                 switch (level) {
17396                         case 1:
17397                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
17398                         break;
17399
17400                         default:
17401                         break;
17402
17403                 }
17404         }
17405         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17406         return NDR_ERR_SUCCESS;
17407 }
17408
17409 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
17410 {
17411         int level;
17412         level = ndr_print_get_switch_value(ndr, r);
17413         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
17414         switch (level) {
17415                 case 1:
17416                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
17417                 break;
17418
17419                 default:
17420                 break;
17421
17422         }
17423 }
17424
17425 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17426 {
17427         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17428         return NDR_ERR_SUCCESS;
17429 }
17430
17431 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17432 {
17433         uint32_t v;
17434         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17435         *r = v;
17436         return NDR_ERR_SUCCESS;
17437 }
17438
17439 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17440 {
17441         ndr_print_uint32(ndr, name, r);
17442         ndr->depth++;
17443         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
17444         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
17445         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
17446         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
17447         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
17448         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
17449         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
17450         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
17451         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
17452         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
17453         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
17454         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
17455         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
17456         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
17457         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
17458         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
17459         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
17460         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
17461         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
17462         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
17463         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
17464         ndr->depth--;
17465 }
17466
17467 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobNotifyField r)
17468 {
17469         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
17470         return NDR_ERR_SUCCESS;
17471 }
17472
17473 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobNotifyField *r)
17474 {
17475         uint16_t v;
17476         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
17477         *r = v;
17478         return NDR_ERR_SUCCESS;
17479 }
17480
17481 _PUBLIC_ void ndr_print_spoolss_JobNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_JobNotifyField r)
17482 {
17483         const char *val = NULL;
17484
17485         switch (r) {
17486                 case JOB_NOTIFY_FIELD_PRINTER_NAME: val = "JOB_NOTIFY_FIELD_PRINTER_NAME"; break;
17487                 case JOB_NOTIFY_FIELD_MACHINE_NAME: val = "JOB_NOTIFY_FIELD_MACHINE_NAME"; break;
17488                 case JOB_NOTIFY_FIELD_PORT_NAME: val = "JOB_NOTIFY_FIELD_PORT_NAME"; break;
17489                 case JOB_NOTIFY_FIELD_USER_NAME: val = "JOB_NOTIFY_FIELD_USER_NAME"; break;
17490                 case JOB_NOTIFY_FIELD_NOTIFY_NAME: val = "JOB_NOTIFY_FIELD_NOTIFY_NAME"; break;
17491                 case JOB_NOTIFY_FIELD_DATATYPE: val = "JOB_NOTIFY_FIELD_DATATYPE"; break;
17492                 case JOB_NOTIFY_FIELD_PRINT_PROCESSOR: val = "JOB_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
17493                 case JOB_NOTIFY_FIELD_PARAMETERS: val = "JOB_NOTIFY_FIELD_PARAMETERS"; break;
17494                 case JOB_NOTIFY_FIELD_DRIVER_NAME: val = "JOB_NOTIFY_FIELD_DRIVER_NAME"; break;
17495                 case JOB_NOTIFY_FIELD_DEVMODE: val = "JOB_NOTIFY_FIELD_DEVMODE"; break;
17496                 case JOB_NOTIFY_FIELD_STATUS: val = "JOB_NOTIFY_FIELD_STATUS"; break;
17497                 case JOB_NOTIFY_FIELD_STATUS_STRING: val = "JOB_NOTIFY_FIELD_STATUS_STRING"; break;
17498                 case JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
17499                 case JOB_NOTIFY_FIELD_DOCUMENT: val = "JOB_NOTIFY_FIELD_DOCUMENT"; break;
17500                 case JOB_NOTIFY_FIELD_PRIORITY: val = "JOB_NOTIFY_FIELD_PRIORITY"; break;
17501                 case JOB_NOTIFY_FIELD_POSITION: val = "JOB_NOTIFY_FIELD_POSITION"; break;
17502                 case JOB_NOTIFY_FIELD_SUBMITTED: val = "JOB_NOTIFY_FIELD_SUBMITTED"; break;
17503                 case JOB_NOTIFY_FIELD_START_TIME: val = "JOB_NOTIFY_FIELD_START_TIME"; break;
17504                 case JOB_NOTIFY_FIELD_UNTIL_TIME: val = "JOB_NOTIFY_FIELD_UNTIL_TIME"; break;
17505                 case JOB_NOTIFY_FIELD_TIME: val = "JOB_NOTIFY_FIELD_TIME"; break;
17506                 case JOB_NOTIFY_FIELD_TOTAL_PAGES: val = "JOB_NOTIFY_FIELD_TOTAL_PAGES"; break;
17507                 case JOB_NOTIFY_FIELD_PAGES_PRINTED: val = "JOB_NOTIFY_FIELD_PAGES_PRINTED"; break;
17508                 case JOB_NOTIFY_FIELD_TOTAL_BYTES: val = "JOB_NOTIFY_FIELD_TOTAL_BYTES"; break;
17509                 case JOB_NOTIFY_FIELD_BYTES_PRINTED: val = "JOB_NOTIFY_FIELD_BYTES_PRINTED"; break;
17510         }
17511         ndr_print_enum(ndr, name, "ENUM", val, r);
17512 }
17513
17514 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrintNotifyField r)
17515 {
17516         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
17517         return NDR_ERR_SUCCESS;
17518 }
17519
17520 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrintNotifyField *r)
17521 {
17522         uint16_t v;
17523         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
17524         *r = v;
17525         return NDR_ERR_SUCCESS;
17526 }
17527
17528 _PUBLIC_ void ndr_print_spoolss_PrintNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_PrintNotifyField r)
17529 {
17530         const char *val = NULL;
17531
17532         switch (r) {
17533                 case PRINTER_NOTIFY_FIELD_SERVER_NAME: val = "PRINTER_NOTIFY_FIELD_SERVER_NAME"; break;
17534                 case PRINTER_NOTIFY_FIELD_PRINTER_NAME: val = "PRINTER_NOTIFY_FIELD_PRINTER_NAME"; break;
17535                 case PRINTER_NOTIFY_FIELD_SHARE_NAME: val = "PRINTER_NOTIFY_FIELD_SHARE_NAME"; break;
17536                 case PRINTER_NOTIFY_FIELD_PORT_NAME: val = "PRINTER_NOTIFY_FIELD_PORT_NAME"; break;
17537                 case PRINTER_NOTIFY_FIELD_DRIVER_NAME: val = "PRINTER_NOTIFY_FIELD_DRIVER_NAME"; break;
17538                 case PRINTER_NOTIFY_FIELD_COMMENT: val = "PRINTER_NOTIFY_FIELD_COMMENT"; break;
17539                 case PRINTER_NOTIFY_FIELD_LOCATION: val = "PRINTER_NOTIFY_FIELD_LOCATION"; break;
17540                 case PRINTER_NOTIFY_FIELD_DEVMODE: val = "PRINTER_NOTIFY_FIELD_DEVMODE"; break;
17541                 case PRINTER_NOTIFY_FIELD_SEPFILE: val = "PRINTER_NOTIFY_FIELD_SEPFILE"; break;
17542                 case PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: val = "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
17543                 case PRINTER_NOTIFY_FIELD_PARAMETERS: val = "PRINTER_NOTIFY_FIELD_PARAMETERS"; break;
17544                 case PRINTER_NOTIFY_FIELD_DATATYPE: val = "PRINTER_NOTIFY_FIELD_DATATYPE"; break;
17545                 case PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
17546                 case PRINTER_NOTIFY_FIELD_ATTRIBUTES: val = "PRINTER_NOTIFY_FIELD_ATTRIBUTES"; break;
17547                 case PRINTER_NOTIFY_FIELD_PRIORITY: val = "PRINTER_NOTIFY_FIELD_PRIORITY"; break;
17548                 case PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: val = "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY"; break;
17549                 case PRINTER_NOTIFY_FIELD_START_TIME: val = "PRINTER_NOTIFY_FIELD_START_TIME"; break;
17550                 case PRINTER_NOTIFY_FIELD_UNTIL_TIME: val = "PRINTER_NOTIFY_FIELD_UNTIL_TIME"; break;
17551                 case PRINTER_NOTIFY_FIELD_STATUS: val = "PRINTER_NOTIFY_FIELD_STATUS"; break;
17552                 case PRINTER_NOTIFY_FIELD_STATUS_STRING: val = "PRINTER_NOTIFY_FIELD_STATUS_STRING"; break;
17553                 case PRINTER_NOTIFY_FIELD_CJOBS: val = "PRINTER_NOTIFY_FIELD_CJOBS"; break;
17554                 case PRINTER_NOTIFY_FIELD_AVERAGE_PPM: val = "PRINTER_NOTIFY_FIELD_AVERAGE_PPM"; break;
17555                 case PRINTER_NOTIFY_FIELD_TOTAL_PAGES: val = "PRINTER_NOTIFY_FIELD_TOTAL_PAGES"; break;
17556                 case PRINTER_NOTIFY_FIELD_PAGES_PRINTED: val = "PRINTER_NOTIFY_FIELD_PAGES_PRINTED"; break;
17557                 case PRINTER_NOTIFY_FIELD_TOTAL_BYTES: val = "PRINTER_NOTIFY_FIELD_TOTAL_BYTES"; break;
17558                 case PRINTER_NOTIFY_FIELD_BYTES_PRINTED: val = "PRINTER_NOTIFY_FIELD_BYTES_PRINTED"; break;
17559                 case PRINTER_NOTIFY_FIELD_OBJECT_GUID: val = "PRINTER_NOTIFY_FIELD_OBJECT_GUID"; break;
17560                 case PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: val = "PRINTER_NOTIFY_FIELD_FRIENDLY_NAME"; break;
17561         }
17562         ndr_print_enum(ndr, name, "ENUM", val, r);
17563 }
17564
17565 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
17566 {
17567         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
17568         return NDR_ERR_SUCCESS;
17569 }
17570
17571 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
17572 {
17573         uint16_t v;
17574         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
17575         *r = v;
17576         return NDR_ERR_SUCCESS;
17577 }
17578
17579 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
17580 {
17581         const char *val = NULL;
17582
17583         switch (r) {
17584                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
17585                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
17586         }
17587         ndr_print_enum(ndr, name, "ENUM", val, r);
17588 }
17589
17590 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, const union spoolss_Field *r)
17591 {
17592         if (ndr_flags & NDR_SCALARS) {
17593                 int level = ndr_push_get_switch_value(ndr, r);
17594                 switch (level) {
17595                         case PRINTER_NOTIFY_TYPE: {
17596                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17597                         break; }
17598
17599                         case JOB_NOTIFY_TYPE: {
17600                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17601                         break; }
17602
17603                         default: {
17604                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17605                         break; }
17606
17607                 }
17608         }
17609         if (ndr_flags & NDR_BUFFERS) {
17610                 int level = ndr_push_get_switch_value(ndr, r);
17611                 switch (level) {
17612                         case PRINTER_NOTIFY_TYPE:
17613                         break;
17614
17615                         case JOB_NOTIFY_TYPE:
17616                         break;
17617
17618                         default:
17619                         break;
17620
17621                 }
17622         }
17623         return NDR_ERR_SUCCESS;
17624 }
17625
17626 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, union spoolss_Field *r)
17627 {
17628         int level;
17629         level = ndr_pull_get_switch_value(ndr, r);
17630         if (ndr_flags & NDR_SCALARS) {
17631                 switch (level) {
17632                         case PRINTER_NOTIFY_TYPE: {
17633                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17634                         break; }
17635
17636                         case JOB_NOTIFY_TYPE: {
17637                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17638                         break; }
17639
17640                         default: {
17641                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17642                         break; }
17643
17644                 }
17645         }
17646         if (ndr_flags & NDR_BUFFERS) {
17647                 switch (level) {
17648                         case PRINTER_NOTIFY_TYPE:
17649                         break;
17650
17651                         case JOB_NOTIFY_TYPE:
17652                         break;
17653
17654                         default:
17655                         break;
17656
17657                 }
17658         }
17659         return NDR_ERR_SUCCESS;
17660 }
17661
17662 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
17663 {
17664         uint32_t cntr_fields_1;
17665         if (ndr_flags & NDR_SCALARS) {
17666                 NDR_CHECK(ndr_push_align(ndr, 4));
17667                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17668                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
17669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
17670                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
17671                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17672                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
17673         }
17674         if (ndr_flags & NDR_BUFFERS) {
17675                 if (r->fields) {
17676                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17677                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17678                                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
17679                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17680                         }
17681                 }
17682         }
17683         return NDR_ERR_SUCCESS;
17684 }
17685
17686 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
17687 {
17688         uint32_t _ptr_fields;
17689         uint32_t cntr_fields_1;
17690         TALLOC_CTX *_mem_save_fields_0;
17691         TALLOC_CTX *_mem_save_fields_1;
17692         if (ndr_flags & NDR_SCALARS) {
17693                 NDR_CHECK(ndr_pull_align(ndr, 4));
17694                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17695                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
17696                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
17697                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
17698                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17699                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
17700                 if (_ptr_fields) {
17701                         NDR_PULL_ALLOC(ndr, r->fields);
17702                 } else {
17703                         r->fields = NULL;
17704                 }
17705         }
17706         if (ndr_flags & NDR_BUFFERS) {
17707                 if (r->fields) {
17708                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
17709                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17710                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
17711                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
17712                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
17713                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17714                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17715                                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
17716                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17717                         }
17718                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
17719                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
17720                 }
17721                 if (r->fields) {
17722                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
17723                 }
17724         }
17725         return NDR_ERR_SUCCESS;
17726 }
17727
17728 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
17729 {
17730         uint32_t cntr_fields_1;
17731         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
17732         ndr->depth++;
17733         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17734         ndr_print_uint16(ndr, "u1", r->u1);
17735         ndr_print_uint32(ndr, "u2", r->u2);
17736         ndr_print_uint32(ndr, "u3", r->u3);
17737         ndr_print_uint32(ndr, "count", r->count);
17738         ndr_print_ptr(ndr, "fields", r->fields);
17739         ndr->depth++;
17740         if (r->fields) {
17741                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
17742                 ndr->depth++;
17743                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
17744                         char *idx_1=NULL;
17745                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
17746                                 ndr_print_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type);
17747                                 ndr_print_spoolss_Field(ndr, "fields", &r->fields[cntr_fields_1]);
17748                                 free(idx_1);
17749                         }
17750                 }
17751                 ndr->depth--;
17752         }
17753         ndr->depth--;
17754         ndr->depth--;
17755 }
17756
17757 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17758 {
17759         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17760         return NDR_ERR_SUCCESS;
17761 }
17762
17763 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17764 {
17765         uint32_t v;
17766         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17767         *r = v;
17768         return NDR_ERR_SUCCESS;
17769 }
17770
17771 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17772 {
17773         ndr_print_uint32(ndr, name, r);
17774         ndr->depth++;
17775         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
17776         ndr->depth--;
17777 }
17778
17779 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
17780 {
17781         uint32_t cntr_types_1;
17782         if (ndr_flags & NDR_SCALARS) {
17783                 NDR_CHECK(ndr_push_align(ndr, 4));
17784                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17785                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
17786                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17787                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
17788         }
17789         if (ndr_flags & NDR_BUFFERS) {
17790                 if (r->types) {
17791                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17792                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17793                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17794                         }
17795                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17796                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17797                         }
17798                 }
17799         }
17800         return NDR_ERR_SUCCESS;
17801 }
17802
17803 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
17804 {
17805         uint32_t _ptr_types;
17806         uint32_t cntr_types_1;
17807         TALLOC_CTX *_mem_save_types_0;
17808         TALLOC_CTX *_mem_save_types_1;
17809         if (ndr_flags & NDR_SCALARS) {
17810                 NDR_CHECK(ndr_pull_align(ndr, 4));
17811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17812                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
17813                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17814                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
17815                 if (_ptr_types) {
17816                         NDR_PULL_ALLOC(ndr, r->types);
17817                 } else {
17818                         r->types = NULL;
17819                 }
17820         }
17821         if (ndr_flags & NDR_BUFFERS) {
17822                 if (r->types) {
17823                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
17824                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17825                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
17826                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
17827                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
17828                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17829                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17830                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17831                         }
17832                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17833                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17834                         }
17835                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
17836                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
17837                 }
17838                 if (r->types) {
17839                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
17840                 }
17841         }
17842         return NDR_ERR_SUCCESS;
17843 }
17844
17845 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
17846 {
17847         uint32_t cntr_types_1;
17848         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
17849         ndr->depth++;
17850         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17851         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
17852         ndr_print_uint32(ndr, "count", r->count);
17853         ndr_print_ptr(ndr, "types", r->types);
17854         ndr->depth++;
17855         if (r->types) {
17856                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
17857                 ndr->depth++;
17858                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
17859                         char *idx_1=NULL;
17860                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
17861                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
17862                                 free(idx_1);
17863                         }
17864                 }
17865                 ndr->depth--;
17866         }
17867         ndr->depth--;
17868         ndr->depth--;
17869 }
17870
17871 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
17872 {
17873         if (ndr_flags & NDR_SCALARS) {
17874                 NDR_CHECK(ndr_push_align(ndr, 4));
17875                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17876                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
17877         }
17878         if (ndr_flags & NDR_BUFFERS) {
17879                 if (r->string) {
17880                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
17881                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
17882                 }
17883         }
17884         return NDR_ERR_SUCCESS;
17885 }
17886
17887 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
17888 {
17889         uint32_t _ptr_string;
17890         TALLOC_CTX *_mem_save_string_0;
17891         if (ndr_flags & NDR_SCALARS) {
17892                 NDR_CHECK(ndr_pull_align(ndr, 4));
17893                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17894                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
17895                 if (_ptr_string) {
17896                         NDR_PULL_ALLOC(ndr, r->string);
17897                 } else {
17898                         r->string = NULL;
17899                 }
17900         }
17901         if (ndr_flags & NDR_BUFFERS) {
17902                 if (r->string) {
17903                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17904                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
17905                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
17906                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
17907                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
17908                 }
17909                 if (r->string) {
17910                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
17911                 }
17912         }
17913         return NDR_ERR_SUCCESS;
17914 }
17915
17916 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
17917 {
17918         ndr_print_struct(ndr, name, "spoolss_NotifyString");
17919         ndr->depth++;
17920         ndr_print_uint32(ndr, "size", r->size);
17921         ndr_print_ptr(ndr, "string", r->string);
17922         ndr->depth++;
17923         if (r->string) {
17924                 ndr_print_string(ndr, "string", r->string);
17925         }
17926         ndr->depth--;
17927         ndr->depth--;
17928 }
17929
17930 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
17931 {
17932         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17933         return NDR_ERR_SUCCESS;
17934 }
17935
17936 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
17937 {
17938         uint32_t v;
17939         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17940         *r = v;
17941         return NDR_ERR_SUCCESS;
17942 }
17943
17944 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
17945 {
17946         const char *val = NULL;
17947
17948         switch (r) {
17949                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
17950                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
17951                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
17952                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
17953                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
17954         }
17955         ndr_print_enum(ndr, name, "ENUM", val, r);
17956 }
17957
17958 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
17959 {
17960         if (ndr_flags & NDR_SCALARS) {
17961                 int level = ndr_push_get_switch_value(ndr, r);
17962                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17963                 switch (level) {
17964                         case 1: {
17965                                 uint32_t cntr_integer_0;
17966                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17967                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
17968                                 }
17969                         break; }
17970
17971                         case 2: {
17972                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17973                         break; }
17974
17975                         case 3: {
17976                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17977                         break; }
17978
17979                         case 4: {
17980                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17981                         break; }
17982
17983                         case 5: {
17984                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17985                         break; }
17986
17987                         default:
17988                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17989                 }
17990         }
17991         if (ndr_flags & NDR_BUFFERS) {
17992                 int level = ndr_push_get_switch_value(ndr, r);
17993                 switch (level) {
17994                         case 1:
17995                         break;
17996
17997                         case 2:
17998                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17999                         break;
18000
18001                         case 3:
18002                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18003                         break;
18004
18005                         case 4:
18006                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18007                         break;
18008
18009                         case 5:
18010                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18011                         break;
18012
18013                         default:
18014                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18015                 }
18016         }
18017         return NDR_ERR_SUCCESS;
18018 }
18019
18020 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
18021 {
18022         int level;
18023         uint32_t _level;
18024         level = ndr_pull_get_switch_value(ndr, r);
18025         if (ndr_flags & NDR_SCALARS) {
18026                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18027                 if (_level != level) {
18028                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
18029                 }
18030                 switch (level) {
18031                         case 1: {
18032                                 uint32_t cntr_integer_0;
18033                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18034                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
18035                                 }
18036                         break; }
18037
18038                         case 2: {
18039                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18040                         break; }
18041
18042                         case 3: {
18043                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18044                         break; }
18045
18046                         case 4: {
18047                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18048                         break; }
18049
18050                         case 5: {
18051                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18052                         break; }
18053
18054                         default:
18055                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18056                 }
18057         }
18058         if (ndr_flags & NDR_BUFFERS) {
18059                 switch (level) {
18060                         case 1:
18061                         break;
18062
18063                         case 2:
18064                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18065                         break;
18066
18067                         case 3:
18068                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18069                         break;
18070
18071                         case 4:
18072                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18073                         break;
18074
18075                         case 5:
18076                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18077                         break;
18078
18079                         default:
18080                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18081                 }
18082         }
18083         return NDR_ERR_SUCCESS;
18084 }
18085
18086 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
18087 {
18088         int level;
18089         uint32_t cntr_integer_0;
18090         level = ndr_print_get_switch_value(ndr, r);
18091         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
18092         switch (level) {
18093                 case 1:
18094                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
18095                         ndr->depth++;
18096                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
18097                                 char *idx_0=NULL;
18098                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
18099                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
18100                                         free(idx_0);
18101                                 }
18102                         }
18103                         ndr->depth--;
18104                 break;
18105
18106                 case 2:
18107                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
18108                 break;
18109
18110                 case 3:
18111                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
18112                 break;
18113
18114                 case 4:
18115                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
18116                 break;
18117
18118                 case 5:
18119                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
18120                 break;
18121
18122                 default:
18123                         ndr_print_bad_level(ndr, name, level);
18124         }
18125 }
18126
18127 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
18128 {
18129         if (ndr_flags & NDR_SCALARS) {
18130                 NDR_CHECK(ndr_push_align(ndr, 4));
18131                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18132                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->field, r->type));
18133                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18134                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
18135                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
18136                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
18137                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18138         }
18139         if (ndr_flags & NDR_BUFFERS) {
18140                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18141         }
18142         return NDR_ERR_SUCCESS;
18143 }
18144
18145 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
18146 {
18147         if (ndr_flags & NDR_SCALARS) {
18148                 NDR_CHECK(ndr_pull_align(ndr, 4));
18149                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18150                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->field, r->type));
18151                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18152                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
18153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
18154                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
18155                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18156         }
18157         if (ndr_flags & NDR_BUFFERS) {
18158                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18159         }
18160         return NDR_ERR_SUCCESS;
18161 }
18162
18163 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
18164 {
18165         ndr_print_struct(ndr, name, "spoolss_Notify");
18166         ndr->depth++;
18167         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
18168         ndr_print_set_switch_value(ndr, &r->field, r->type);
18169         ndr_print_spoolss_Field(ndr, "field", &r->field);
18170         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
18171         ndr_print_uint32(ndr, "job_id", r->job_id);
18172         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
18173         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
18174         ndr->depth--;
18175 }
18176
18177 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
18178 {
18179         uint32_t cntr_notifies_0;
18180         if (ndr_flags & NDR_SCALARS) {
18181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18182                 NDR_CHECK(ndr_push_align(ndr, 4));
18183                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
18184                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
18185                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18186                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18187                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
18188                 }
18189         }
18190         if (ndr_flags & NDR_BUFFERS) {
18191                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18192                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
18193                 }
18194         }
18195         return NDR_ERR_SUCCESS;
18196 }
18197
18198 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
18199 {
18200         uint32_t cntr_notifies_0;
18201         TALLOC_CTX *_mem_save_notifies_0;
18202         if (ndr_flags & NDR_SCALARS) {
18203                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
18204                 NDR_CHECK(ndr_pull_align(ndr, 4));
18205                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18206                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
18207                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18208                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
18209                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
18210                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
18211                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18212                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
18213                 }
18214                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
18215                 if (r->notifies) {
18216                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
18217                 }
18218         }
18219         if (ndr_flags & NDR_BUFFERS) {
18220                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
18221                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
18222                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18223                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
18224                 }
18225                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
18226         }
18227         return NDR_ERR_SUCCESS;
18228 }
18229
18230 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
18231 {
18232         uint32_t cntr_notifies_0;
18233         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
18234         ndr->depth++;
18235         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
18236         ndr_print_uint32(ndr, "flags", r->flags);
18237         ndr_print_uint32(ndr, "count", r->count);
18238         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
18239         ndr->depth++;
18240         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
18241                 char *idx_0=NULL;
18242                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
18243                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
18244                         free(idx_0);
18245                 }
18246         }
18247         ndr->depth--;
18248         ndr->depth--;
18249 }
18250
18251 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
18252 {
18253         if (ndr_flags & NDR_SCALARS) {
18254                 int level = ndr_push_get_switch_value(ndr, r);
18255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18256                 switch (level) {
18257                         case 0: {
18258                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
18259                         break; }
18260
18261                         default:
18262                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18263                 }
18264         }
18265         if (ndr_flags & NDR_BUFFERS) {
18266                 int level = ndr_push_get_switch_value(ndr, r);
18267                 switch (level) {
18268                         case 0:
18269                                 if (r->info0) {
18270                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
18271                                 }
18272                         break;
18273
18274                         default:
18275                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18276                 }
18277         }
18278         return NDR_ERR_SUCCESS;
18279 }
18280
18281 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
18282 {
18283         int level;
18284         uint32_t _level;
18285         TALLOC_CTX *_mem_save_info0_0;
18286         level = ndr_pull_get_switch_value(ndr, r);
18287         if (ndr_flags & NDR_SCALARS) {
18288                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18289                 if (_level != level) {
18290                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
18291                 }
18292                 switch (level) {
18293                         case 0: {
18294                                 uint32_t _ptr_info0;
18295                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
18296                                 if (_ptr_info0) {
18297                                         NDR_PULL_ALLOC(ndr, r->info0);
18298                                 } else {
18299                                         r->info0 = NULL;
18300                                 }
18301                         break; }
18302
18303                         default:
18304                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18305                 }
18306         }
18307         if (ndr_flags & NDR_BUFFERS) {
18308                 switch (level) {
18309                         case 0:
18310                                 if (r->info0) {
18311                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
18312                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
18313                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
18314                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
18315                                 }
18316                         break;
18317
18318                         default:
18319                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18320                 }
18321         }
18322         return NDR_ERR_SUCCESS;
18323 }
18324
18325 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
18326 {
18327         int level;
18328         level = ndr_print_get_switch_value(ndr, r);
18329         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
18330         switch (level) {
18331                 case 0:
18332                         ndr_print_ptr(ndr, "info0", r->info0);
18333                         ndr->depth++;
18334                         if (r->info0) {
18335                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
18336                         }
18337                         ndr->depth--;
18338                 break;
18339
18340                 default:
18341                         ndr_print_bad_level(ndr, name, level);
18342         }
18343 }
18344
18345 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18346 {
18347         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18348         return NDR_ERR_SUCCESS;
18349 }
18350
18351 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18352 {
18353         uint32_t v;
18354         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18355         *r = v;
18356         return NDR_ERR_SUCCESS;
18357 }
18358
18359 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18360 {
18361         ndr_print_uint32(ndr, name, r);
18362         ndr->depth++;
18363         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
18364         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
18365         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
18366         ndr->depth--;
18367 }
18368
18369 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
18370 {
18371         if (ndr_flags & NDR_SCALARS) {
18372                 NDR_CHECK(ndr_push_align(ndr, 4));
18373                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18374                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
18375                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
18376                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
18377                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
18378                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
18379                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
18380         }
18381         if (ndr_flags & NDR_BUFFERS) {
18382                 if (r->client) {
18383                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18384                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18386                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18387                 }
18388                 if (r->user) {
18389                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18390                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18391                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18392                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18393                 }
18394         }
18395         return NDR_ERR_SUCCESS;
18396 }
18397
18398 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
18399 {
18400         uint32_t _ptr_client;
18401         TALLOC_CTX *_mem_save_client_0;
18402         uint32_t _ptr_user;
18403         TALLOC_CTX *_mem_save_user_0;
18404         if (ndr_flags & NDR_SCALARS) {
18405                 NDR_CHECK(ndr_pull_align(ndr, 4));
18406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18407                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
18408                 if (_ptr_client) {
18409                         NDR_PULL_ALLOC(ndr, r->client);
18410                 } else {
18411                         r->client = NULL;
18412                 }
18413                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
18414                 if (_ptr_user) {
18415                         NDR_PULL_ALLOC(ndr, r->user);
18416                 } else {
18417                         r->user = NULL;
18418                 }
18419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
18420                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
18421                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
18422                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
18423         }
18424         if (ndr_flags & NDR_BUFFERS) {
18425                 if (r->client) {
18426                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
18427                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
18428                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
18429                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
18430                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
18431                                 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));
18432                         }
18433                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
18434                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
18435                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
18436                 }
18437                 if (r->user) {
18438                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
18439                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
18440                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
18441                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
18442                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
18443                                 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));
18444                         }
18445                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
18446                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
18447                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
18448                 }
18449         }
18450         return NDR_ERR_SUCCESS;
18451 }
18452
18453 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
18454 {
18455         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
18456         ndr->depth++;
18457         ndr_print_uint32(ndr, "size", r->size);
18458         ndr_print_ptr(ndr, "client", r->client);
18459         ndr->depth++;
18460         if (r->client) {
18461                 ndr_print_string(ndr, "client", r->client);
18462         }
18463         ndr->depth--;
18464         ndr_print_ptr(ndr, "user", r->user);
18465         ndr->depth++;
18466         if (r->user) {
18467                 ndr_print_string(ndr, "user", r->user);
18468         }
18469         ndr->depth--;
18470         ndr_print_uint32(ndr, "build", r->build);
18471         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
18472         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
18473         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
18474         ndr->depth--;
18475 }
18476
18477 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
18478 {
18479         if (ndr_flags & NDR_SCALARS) {
18480                 NDR_CHECK(ndr_push_align(ndr, 4));
18481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
18482         }
18483         if (ndr_flags & NDR_BUFFERS) {
18484         }
18485         return NDR_ERR_SUCCESS;
18486 }
18487
18488 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
18489 {
18490         if (ndr_flags & NDR_SCALARS) {
18491                 NDR_CHECK(ndr_pull_align(ndr, 4));
18492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
18493         }
18494         if (ndr_flags & NDR_BUFFERS) {
18495         }
18496         return NDR_ERR_SUCCESS;
18497 }
18498
18499 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
18500 {
18501         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
18502         ndr->depth++;
18503         ndr_print_uint32(ndr, "not_used", r->not_used);
18504         ndr->depth--;
18505 }
18506
18507 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
18508 {
18509         if (ndr_flags & NDR_SCALARS) {
18510                 NDR_CHECK(ndr_push_align(ndr, 4));
18511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
18513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
18514                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
18515                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
18516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
18517                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
18518                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
18519                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
18520                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
18521         }
18522         if (ndr_flags & NDR_BUFFERS) {
18523                 if (r->client) {
18524                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18525                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18526                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18527                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18528                 }
18529                 if (r->user) {
18530                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18531                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18532                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18533                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18534                 }
18535         }
18536         return NDR_ERR_SUCCESS;
18537 }
18538
18539 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
18540 {
18541         uint32_t _ptr_client;
18542         TALLOC_CTX *_mem_save_client_0;
18543         uint32_t _ptr_user;
18544         TALLOC_CTX *_mem_save_user_0;
18545         if (ndr_flags & NDR_SCALARS) {
18546                 NDR_CHECK(ndr_pull_align(ndr, 4));
18547                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
18549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
18550                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
18551                 if (_ptr_client) {
18552                         NDR_PULL_ALLOC(ndr, r->client);
18553                 } else {
18554                         r->client = NULL;
18555                 }
18556                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
18557                 if (_ptr_user) {
18558                         NDR_PULL_ALLOC(ndr, r->user);
18559                 } else {
18560                         r->user = NULL;
18561                 }
18562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
18563                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
18564                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
18565                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
18566                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
18567         }
18568         if (ndr_flags & NDR_BUFFERS) {
18569                 if (r->client) {
18570                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
18571                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
18572                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
18573                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
18574                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
18575                                 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));
18576                         }
18577                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
18578                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
18579                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
18580                 }
18581                 if (r->user) {
18582                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
18583                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
18584                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
18585                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
18586                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
18587                                 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));
18588                         }
18589                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
18590                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
18591                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
18592                 }
18593         }
18594         return NDR_ERR_SUCCESS;
18595 }
18596
18597 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
18598 {
18599         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
18600         ndr->depth++;
18601         ndr_print_uint32(ndr, "size", r->size);
18602         ndr_print_uint32(ndr, "flags", r->flags);
18603         ndr_print_uint32(ndr, "size2", r->size2);
18604         ndr_print_ptr(ndr, "client", r->client);
18605         ndr->depth++;
18606         if (r->client) {
18607                 ndr_print_string(ndr, "client", r->client);
18608         }
18609         ndr->depth--;
18610         ndr_print_ptr(ndr, "user", r->user);
18611         ndr->depth++;
18612         if (r->user) {
18613                 ndr_print_string(ndr, "user", r->user);
18614         }
18615         ndr->depth--;
18616         ndr_print_uint32(ndr, "build", r->build);
18617         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
18618         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
18619         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
18620         ndr_print_udlong(ndr, "reserved", r->reserved);
18621         ndr->depth--;
18622 }
18623
18624 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
18625 {
18626         if (ndr_flags & NDR_SCALARS) {
18627                 int level = ndr_push_get_switch_value(ndr, r);
18628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18629                 switch (level) {
18630                         case 1: {
18631                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
18632                         break; }
18633
18634                         case 2: {
18635                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
18636                         break; }
18637
18638                         case 3: {
18639                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
18640                         break; }
18641
18642                         default:
18643                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18644                 }
18645         }
18646         if (ndr_flags & NDR_BUFFERS) {
18647                 int level = ndr_push_get_switch_value(ndr, r);
18648                 switch (level) {
18649                         case 1:
18650                                 if (r->level1) {
18651                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18652                                 }
18653                         break;
18654
18655                         case 2:
18656                                 if (r->level2) {
18657                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18658                                 }
18659                         break;
18660
18661                         case 3:
18662                                 if (r->level3) {
18663                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18664                                 }
18665                         break;
18666
18667                         default:
18668                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18669                 }
18670         }
18671         return NDR_ERR_SUCCESS;
18672 }
18673
18674 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
18675 {
18676         int level;
18677         uint32_t _level;
18678         TALLOC_CTX *_mem_save_level1_0;
18679         TALLOC_CTX *_mem_save_level2_0;
18680         TALLOC_CTX *_mem_save_level3_0;
18681         level = ndr_pull_get_switch_value(ndr, r);
18682         if (ndr_flags & NDR_SCALARS) {
18683                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18684                 if (_level != level) {
18685                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
18686                 }
18687                 switch (level) {
18688                         case 1: {
18689                                 uint32_t _ptr_level1;
18690                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
18691                                 if (_ptr_level1) {
18692                                         NDR_PULL_ALLOC(ndr, r->level1);
18693                                 } else {
18694                                         r->level1 = NULL;
18695                                 }
18696                         break; }
18697
18698                         case 2: {
18699                                 uint32_t _ptr_level2;
18700                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
18701                                 if (_ptr_level2) {
18702                                         NDR_PULL_ALLOC(ndr, r->level2);
18703                                 } else {
18704                                         r->level2 = NULL;
18705                                 }
18706                         break; }
18707
18708                         case 3: {
18709                                 uint32_t _ptr_level3;
18710                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
18711                                 if (_ptr_level3) {
18712                                         NDR_PULL_ALLOC(ndr, r->level3);
18713                                 } else {
18714                                         r->level3 = NULL;
18715                                 }
18716                         break; }
18717
18718                         default:
18719                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18720                 }
18721         }
18722         if (ndr_flags & NDR_BUFFERS) {
18723                 switch (level) {
18724                         case 1:
18725                                 if (r->level1) {
18726                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
18727                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
18728                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18729                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
18730                                 }
18731                         break;
18732
18733                         case 2:
18734                                 if (r->level2) {
18735                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
18736                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
18737                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18738                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
18739                                 }
18740                         break;
18741
18742                         case 3:
18743                                 if (r->level3) {
18744                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
18745                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
18746                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18747                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
18748                                 }
18749                         break;
18750
18751                         default:
18752                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18753                 }
18754         }
18755         return NDR_ERR_SUCCESS;
18756 }
18757
18758 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
18759 {
18760         int level;
18761         level = ndr_print_get_switch_value(ndr, r);
18762         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
18763         switch (level) {
18764                 case 1:
18765                         ndr_print_ptr(ndr, "level1", r->level1);
18766                         ndr->depth++;
18767                         if (r->level1) {
18768                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
18769                         }
18770                         ndr->depth--;
18771                 break;
18772
18773                 case 2:
18774                         ndr_print_ptr(ndr, "level2", r->level2);
18775                         ndr->depth++;
18776                         if (r->level2) {
18777                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
18778                         }
18779                         ndr->depth--;
18780                 break;
18781
18782                 case 3:
18783                         ndr_print_ptr(ndr, "level3", r->level3);
18784                         ndr->depth++;
18785                         if (r->level3) {
18786                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
18787                         }
18788                         ndr->depth--;
18789                 break;
18790
18791                 default:
18792                         ndr_print_bad_level(ndr, name, level);
18793         }
18794 }
18795
18796 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
18797 {
18798         if (ndr_flags & NDR_SCALARS) {
18799                 NDR_CHECK(ndr_push_align(ndr, 4));
18800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
18801                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
18802                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18803         }
18804         if (ndr_flags & NDR_BUFFERS) {
18805                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18806         }
18807         return NDR_ERR_SUCCESS;
18808 }
18809
18810 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
18811 {
18812         if (ndr_flags & NDR_SCALARS) {
18813                 NDR_CHECK(ndr_pull_align(ndr, 4));
18814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
18815                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
18816                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18817         }
18818         if (ndr_flags & NDR_BUFFERS) {
18819                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18820         }
18821         return NDR_ERR_SUCCESS;
18822 }
18823
18824 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
18825 {
18826         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
18827         ndr->depth++;
18828         ndr_print_uint32(ndr, "level", r->level);
18829         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
18830         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
18831         ndr->depth--;
18832 }
18833
18834 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18835 {
18836         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18837         return NDR_ERR_SUCCESS;
18838 }
18839
18840 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18841 {
18842         uint32_t v;
18843         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18844         *r = v;
18845         return NDR_ERR_SUCCESS;
18846 }
18847
18848 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
18849 {
18850         ndr_print_uint32(ndr, name, r);
18851         ndr->depth++;
18852         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
18853         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
18854         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
18855         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
18856         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
18857         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
18858         ndr->depth--;
18859 }
18860
18861 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
18862 {
18863         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18864         if (ndr_flags & NDR_SCALARS) {
18865                 NDR_CHECK(ndr_push_align(ndr, 4));
18866                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18867                 {
18868                         uint32_t _flags_save_string = ndr->flags;
18869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18870                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
18871                         ndr->flags = _flags_save_string;
18872                 }
18873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
18874                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
18875                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
18876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags)));
18877         }
18878         if (ndr_flags & NDR_BUFFERS) {
18879                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18880                 {
18881                         uint32_t _flags_save_string = ndr->flags;
18882                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18883                         if (r->value_name) {
18884                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value_name));
18885                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
18886                         }
18887                         ndr->flags = _flags_save_string;
18888                 }
18889                 if (r->data) {
18890                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data));
18891                         {
18892                                 struct ndr_push *_ndr_data;
18893                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
18894                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_data, r->data, r->type));
18895                                 NDR_CHECK(ndr_push_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
18896                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data_length));
18897                         }
18898                 }
18899         }
18900         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18901         return NDR_ERR_SUCCESS;
18902 }
18903
18904 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
18905 {
18906         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18907         uint32_t _ptr_value_name;
18908         TALLOC_CTX *_mem_save_value_name_0;
18909         uint32_t _ptr_data;
18910         TALLOC_CTX *_mem_save_data_0;
18911         if (ndr_flags & NDR_SCALARS) {
18912                 NDR_CHECK(ndr_pull_align(ndr, 4));
18913                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18914                 {
18915                         uint32_t _flags_save_string = ndr->flags;
18916                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18917                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
18918                         if (_ptr_value_name) {
18919                                 NDR_PULL_ALLOC(ndr, r->value_name);
18920                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
18921                         } else {
18922                                 r->value_name = NULL;
18923                         }
18924                         ndr->flags = _flags_save_string;
18925                 }
18926                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
18927                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
18928                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
18929                 if (_ptr_data) {
18930                         NDR_PULL_ALLOC(ndr, r->data);
18931                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
18932                 } else {
18933                         r->data = NULL;
18934                 }
18935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
18936         }
18937         if (ndr_flags & NDR_BUFFERS) {
18938                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18939                 {
18940                         uint32_t _flags_save_string = ndr->flags;
18941                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18942                         if (r->value_name) {
18943                                 uint32_t _relative_save_offset;
18944                                 _relative_save_offset = ndr->offset;
18945                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
18946                                 _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18947                                 NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
18948                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
18949                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
18950                                 ndr->offset = _relative_save_offset;
18951                         }
18952                         ndr->flags = _flags_save_string;
18953                 }
18954                 if (r->data) {
18955                         uint32_t _relative_save_offset;
18956                         _relative_save_offset = ndr->offset;
18957                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
18958                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
18959                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
18960                         {
18961                                 struct ndr_pull *_ndr_data;
18962                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
18963                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, r->data, r->type));
18964                                 NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
18965                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
18966                         }
18967                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
18968                         ndr->offset = _relative_save_offset;
18969                 }
18970         }
18971         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18972         return NDR_ERR_SUCCESS;
18973 }
18974
18975 _PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
18976 {
18977         ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
18978         ndr->depth++;
18979         ndr_print_ptr(ndr, "value_name", r->value_name);
18980         ndr->depth++;
18981         if (r->value_name) {
18982                 ndr_print_string(ndr, "value_name", r->value_name);
18983         }
18984         ndr->depth--;
18985         ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
18986         ndr_print_winreg_Type(ndr, "type", r->type);
18987         ndr_print_ptr(ndr, "data", r->data);
18988         ndr->depth++;
18989         if (r->data) {
18990                 ndr_print_set_switch_value(ndr, r->data, r->type);
18991                 ndr_print_spoolss_PrinterData(ndr, "data", r->data);
18992         }
18993         ndr->depth--;
18994         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);
18995         ndr->depth--;
18996 }
18997
18998 _PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
18999 {
19000         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
19001 }
19002
19003 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19004 {
19005         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19006         return NDR_ERR_SUCCESS;
19007 }
19008
19009 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19010 {
19011         uint32_t v;
19012         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19013         *r = v;
19014         return NDR_ERR_SUCCESS;
19015 }
19016
19017 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19018 {
19019         ndr_print_uint32(ndr, name, r);
19020         ndr->depth++;
19021         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
19022         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
19023         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
19024         ndr->depth--;
19025 }
19026
19027 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
19028 {
19029         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19030         return NDR_ERR_SUCCESS;
19031 }
19032
19033 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
19034 {
19035         uint32_t v;
19036         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19037         *r = v;
19038         return NDR_ERR_SUCCESS;
19039 }
19040
19041 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
19042 {
19043         const char *val = NULL;
19044
19045         switch (r) {
19046                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
19047                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
19048         }
19049         ndr_print_enum(ndr, name, "ENUM", val, r);
19050 }
19051
19052 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
19053 {
19054         if (ndr_flags & NDR_SCALARS) {
19055                 NDR_CHECK(ndr_push_align(ndr, 4));
19056                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
19057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
19058                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
19059                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
19060                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
19061                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
19062                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
19064                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
19065                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
19066                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
19067                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19068                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
19069                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
19070                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
19071         }
19072         if (ndr_flags & NDR_BUFFERS) {
19073         }
19074         return NDR_ERR_SUCCESS;
19075 }
19076
19077 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
19078 {
19079         if (ndr_flags & NDR_SCALARS) {
19080                 NDR_CHECK(ndr_pull_align(ndr, 4));
19081                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
19082                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19083                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
19084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19085                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
19086                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
19087                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19088                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
19089                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
19090                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
19091                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
19092                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
19094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
19095                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
19096         }
19097         if (ndr_flags & NDR_BUFFERS) {
19098         }
19099         return NDR_ERR_SUCCESS;
19100 }
19101
19102 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
19103 {
19104         ndr_print_struct(ndr, name, "spoolss_PortData1");
19105         ndr->depth++;
19106         ndr_print_string(ndr, "portname", r->portname);
19107         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
19108         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
19109         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
19110         ndr_print_uint32(ndr, "reserved", r->reserved);
19111         ndr_print_string(ndr, "hostaddress", r->hostaddress);
19112         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
19113         ndr_print_uint32(ndr, "dblspool", r->dblspool);
19114         ndr_print_string(ndr, "queue", r->queue);
19115         ndr_print_string(ndr, "ip_address", r->ip_address);
19116         ndr_print_string(ndr, "hardware_address", r->hardware_address);
19117         ndr_print_string(ndr, "device_type", r->device_type);
19118         ndr_print_uint32(ndr, "port_number", r->port_number);
19119         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
19120         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
19121         ndr->depth--;
19122 }
19123
19124 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
19125 {
19126         if (ndr_flags & NDR_SCALARS) {
19127                 NDR_CHECK(ndr_push_align(ndr, 4));
19128                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
19129                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
19130                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
19131                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
19132                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
19133                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
19134                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19135                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
19136                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
19137                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19138                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
19139                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
19140                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
19141                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
19142         }
19143         if (ndr_flags & NDR_BUFFERS) {
19144         }
19145         return NDR_ERR_SUCCESS;
19146 }
19147
19148 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
19149 {
19150         if (ndr_flags & NDR_SCALARS) {
19151                 NDR_CHECK(ndr_pull_align(ndr, 4));
19152                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
19153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19154                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
19155                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
19157                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
19158                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
19160                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
19161                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
19163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
19164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
19165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
19166         }
19167         if (ndr_flags & NDR_BUFFERS) {
19168         }
19169         return NDR_ERR_SUCCESS;
19170 }
19171
19172 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
19173 {
19174         ndr_print_struct(ndr, name, "spoolss_PortData2");
19175         ndr->depth++;
19176         ndr_print_string(ndr, "portname", r->portname);
19177         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
19178         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
19179         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
19180         ndr_print_uint32(ndr, "reserved", r->reserved);
19181         ndr_print_string(ndr, "hostaddress", r->hostaddress);
19182         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
19183         ndr_print_uint32(ndr, "dblspool", r->dblspool);
19184         ndr_print_string(ndr, "queue", r->queue);
19185         ndr_print_string(ndr, "device_type", r->device_type);
19186         ndr_print_uint32(ndr, "port_number", r->port_number);
19187         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
19188         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
19189         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
19190         ndr->depth--;
19191 }
19192
19193 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
19194 {
19195         if (ndr_flags & NDR_SCALARS) {
19196                 NDR_CHECK(ndr_push_align(ndr, 4));
19197                 {
19198                         uint32_t _flags_save_string = ndr->flags;
19199                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19200                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
19201                         ndr->flags = _flags_save_string;
19202                 }
19203         }
19204         if (ndr_flags & NDR_BUFFERS) {
19205         }
19206         return NDR_ERR_SUCCESS;
19207 }
19208
19209 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
19210 {
19211         if (ndr_flags & NDR_SCALARS) {
19212                 NDR_CHECK(ndr_pull_align(ndr, 4));
19213                 {
19214                         uint32_t _flags_save_string = ndr->flags;
19215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19216                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
19217                         ndr->flags = _flags_save_string;
19218                 }
19219         }
19220         if (ndr_flags & NDR_BUFFERS) {
19221         }
19222         return NDR_ERR_SUCCESS;
19223 }
19224
19225 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
19226 {
19227         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
19228         ndr->depth++;
19229         ndr_print_string(ndr, "dll_name", r->dll_name);
19230         ndr->depth--;
19231 }
19232
19233 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19234 {
19235         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19236         return NDR_ERR_SUCCESS;
19237 }
19238
19239 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19240 {
19241         uint32_t v;
19242         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19243         *r = v;
19244         return NDR_ERR_SUCCESS;
19245 }
19246
19247 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19248 {
19249         ndr_print_uint32(ndr, name, r);
19250         ndr->depth++;
19251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
19252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
19253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
19254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
19255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
19256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
19257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
19258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
19259         ndr->depth--;
19260 }
19261
19262 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
19263 {
19264         if (flags & NDR_IN) {
19265                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
19266                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19267                 if (r->in.server) {
19268                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19269                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19270                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19271                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19272                 }
19273                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19274                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19275                 if (r->in.buffer) {
19276                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19277                 }
19278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19279         }
19280         if (flags & NDR_OUT) {
19281                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19282                 if (r->out.info) {
19283                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19284                 }
19285                 if (r->out.needed == NULL) {
19286                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19287                 }
19288                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19289                 if (r->out.count == NULL) {
19290                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19291                 }
19292                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19293                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19294         }
19295         return NDR_ERR_SUCCESS;
19296 }
19297
19298 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
19299 {
19300         uint32_t _ptr_server;
19301         uint32_t _ptr_buffer;
19302         uint32_t _ptr_info;
19303         TALLOC_CTX *_mem_save_server_0;
19304         TALLOC_CTX *_mem_save_buffer_0;
19305         TALLOC_CTX *_mem_save_info_0;
19306         TALLOC_CTX *_mem_save_needed_0;
19307         TALLOC_CTX *_mem_save_count_0;
19308         if (flags & NDR_IN) {
19309                 ZERO_STRUCT(r->out);
19310
19311                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
19312                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
19313                 if (_ptr_server) {
19314                         NDR_PULL_ALLOC(ndr, r->in.server);
19315                 } else {
19316                         r->in.server = NULL;
19317                 }
19318                 if (r->in.server) {
19319                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
19320                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
19321                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
19322                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
19323                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
19324                                 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));
19325                         }
19326                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
19327                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
19328                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
19329                 }
19330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19331                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19332                 if (_ptr_buffer) {
19333                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19334                 } else {
19335                         r->in.buffer = NULL;
19336                 }
19337                 if (r->in.buffer) {
19338                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19339                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19340                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19341                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19342                 }
19343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19344                 NDR_PULL_ALLOC(ndr, r->out.needed);
19345                 ZERO_STRUCTP(r->out.needed);
19346                 NDR_PULL_ALLOC(ndr, r->out.count);
19347                 ZERO_STRUCTP(r->out.count);
19348         }
19349         if (flags & NDR_OUT) {
19350                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19351                 if (_ptr_info) {
19352                         NDR_PULL_ALLOC(ndr, r->out.info);
19353                 } else {
19354                         r->out.info = NULL;
19355                 }
19356                 if (r->out.info) {
19357                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19358                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19359                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19360                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19361                 }
19362                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19363                         NDR_PULL_ALLOC(ndr, r->out.needed);
19364                 }
19365                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19366                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19367                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19368                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19369                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19370                         NDR_PULL_ALLOC(ndr, r->out.count);
19371                 }
19372                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19373                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19375                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19376                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19377         }
19378         return NDR_ERR_SUCCESS;
19379 }
19380
19381 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
19382 {
19383         uint32_t cntr_info_0;
19384         if (flags & NDR_IN) {
19385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19387         }
19388         if (flags & NDR_OUT) {
19389                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19390                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19391                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19392                 }
19393                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19394                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19395                 }
19396         }
19397         return NDR_ERR_SUCCESS;
19398 }
19399
19400 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
19401 {
19402         uint32_t cntr_info_0;
19403         TALLOC_CTX *_mem_save_info_0;
19404         if (flags & NDR_IN) {
19405                 ZERO_STRUCT(r->out);
19406
19407                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19408                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19409         }
19410         if (flags & NDR_OUT) {
19411                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19412                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19413                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19414                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19415                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19416                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19417                 }
19418                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19419                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19420                 }
19421                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19422         }
19423         return NDR_ERR_SUCCESS;
19424 }
19425
19426 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
19427 {
19428         uint32_t cntr_info_2;
19429         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
19430         ndr->depth++;
19431         if (flags & NDR_SET_VALUES) {
19432                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19433         }
19434         if (flags & NDR_IN) {
19435                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
19436                 ndr->depth++;
19437                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
19438                 ndr_print_ptr(ndr, "server", r->in.server);
19439                 ndr->depth++;
19440                 if (r->in.server) {
19441                         ndr_print_string(ndr, "server", r->in.server);
19442                 }
19443                 ndr->depth--;
19444                 ndr_print_uint32(ndr, "level", r->in.level);
19445                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19446                 ndr->depth++;
19447                 if (r->in.buffer) {
19448                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19449                 }
19450                 ndr->depth--;
19451                 ndr_print_uint32(ndr, "offered", r->in.offered);
19452                 ndr->depth--;
19453         }
19454         if (flags & NDR_OUT) {
19455                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
19456                 ndr->depth++;
19457                 ndr_print_ptr(ndr, "count", r->out.count);
19458                 ndr->depth++;
19459                 ndr_print_uint32(ndr, "count", *r->out.count);
19460                 ndr->depth--;
19461                 ndr_print_ptr(ndr, "info", r->out.info);
19462                 ndr->depth++;
19463                 ndr_print_ptr(ndr, "info", *r->out.info);
19464                 ndr->depth++;
19465                 if (*r->out.info) {
19466                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19467                         ndr->depth++;
19468                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19469                                 char *idx_2=NULL;
19470                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19471                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19472                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19473                                         free(idx_2);
19474                                 }
19475                         }
19476                         ndr->depth--;
19477                 }
19478                 ndr->depth--;
19479                 ndr->depth--;
19480                 ndr_print_ptr(ndr, "needed", r->out.needed);
19481                 ndr->depth++;
19482                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19483                 ndr->depth--;
19484                 ndr_print_WERROR(ndr, "result", r->out.result);
19485                 ndr->depth--;
19486         }
19487         ndr->depth--;
19488 }
19489
19490 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
19491 {
19492         if (flags & NDR_IN) {
19493                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
19494                 if (r->in.printername) {
19495                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
19496                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19497                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
19498                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19499                 }
19500                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
19501                 if (r->in.datatype) {
19502                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
19503                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19504                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
19505                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19506                 }
19507                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
19508                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
19509         }
19510         if (flags & NDR_OUT) {
19511                 if (r->out.handle == NULL) {
19512                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19513                 }
19514                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19515                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19516         }
19517         return NDR_ERR_SUCCESS;
19518 }
19519
19520 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
19521 {
19522         uint32_t _ptr_printername;
19523         uint32_t _ptr_datatype;
19524         TALLOC_CTX *_mem_save_printername_0;
19525         TALLOC_CTX *_mem_save_datatype_0;
19526         TALLOC_CTX *_mem_save_handle_0;
19527         if (flags & NDR_IN) {
19528                 ZERO_STRUCT(r->out);
19529
19530                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
19531                 if (_ptr_printername) {
19532                         NDR_PULL_ALLOC(ndr, r->in.printername);
19533                 } else {
19534                         r->in.printername = NULL;
19535                 }
19536                 if (r->in.printername) {
19537                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19538                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
19539                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
19540                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
19541                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
19542                                 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));
19543                         }
19544                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
19545                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
19546                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
19547                 }
19548                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
19549                 if (_ptr_datatype) {
19550                         NDR_PULL_ALLOC(ndr, r->in.datatype);
19551                 } else {
19552                         r->in.datatype = NULL;
19553                 }
19554                 if (r->in.datatype) {
19555                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
19556                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
19557                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
19558                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
19559                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
19560                                 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));
19561                         }
19562                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
19563                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
19564                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
19565                 }
19566                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
19567                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
19568                 NDR_PULL_ALLOC(ndr, r->out.handle);
19569                 ZERO_STRUCTP(r->out.handle);
19570         }
19571         if (flags & NDR_OUT) {
19572                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19573                         NDR_PULL_ALLOC(ndr, r->out.handle);
19574                 }
19575                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19576                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
19577                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19578                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19579                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19580         }
19581         return NDR_ERR_SUCCESS;
19582 }
19583
19584 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
19585 {
19586         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
19587         ndr->depth++;
19588         if (flags & NDR_SET_VALUES) {
19589                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19590         }
19591         if (flags & NDR_IN) {
19592                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
19593                 ndr->depth++;
19594                 ndr_print_ptr(ndr, "printername", r->in.printername);
19595                 ndr->depth++;
19596                 if (r->in.printername) {
19597                         ndr_print_string(ndr, "printername", r->in.printername);
19598                 }
19599                 ndr->depth--;
19600                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
19601                 ndr->depth++;
19602                 if (r->in.datatype) {
19603                         ndr_print_string(ndr, "datatype", r->in.datatype);
19604                 }
19605                 ndr->depth--;
19606                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
19607                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
19608                 ndr->depth--;
19609         }
19610         if (flags & NDR_OUT) {
19611                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
19612                 ndr->depth++;
19613                 ndr_print_ptr(ndr, "handle", r->out.handle);
19614                 ndr->depth++;
19615                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
19616                 ndr->depth--;
19617                 ndr_print_WERROR(ndr, "result", r->out.result);
19618                 ndr->depth--;
19619         }
19620         ndr->depth--;
19621 }
19622
19623 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
19624 {
19625         if (flags & NDR_IN) {
19626                 if (r->in.handle == NULL) {
19627                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19628                 }
19629                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19630                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
19631                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
19632                 if (r->in.ctr) {
19633                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
19634                 }
19635                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
19636         }
19637         if (flags & NDR_OUT) {
19638                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19639         }
19640         return NDR_ERR_SUCCESS;
19641 }
19642
19643 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
19644 {
19645         uint32_t _ptr_ctr;
19646         TALLOC_CTX *_mem_save_handle_0;
19647         TALLOC_CTX *_mem_save_ctr_0;
19648         if (flags & NDR_IN) {
19649                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19650                         NDR_PULL_ALLOC(ndr, r->in.handle);
19651                 }
19652                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19653                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19654                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19655                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
19657                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
19658                 if (_ptr_ctr) {
19659                         NDR_PULL_ALLOC(ndr, r->in.ctr);
19660                 } else {
19661                         r->in.ctr = NULL;
19662                 }
19663                 if (r->in.ctr) {
19664                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19665                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
19666                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
19667                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
19668                 }
19669                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
19670         }
19671         if (flags & NDR_OUT) {
19672                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19673         }
19674         return NDR_ERR_SUCCESS;
19675 }
19676
19677 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
19678 {
19679         ndr_print_struct(ndr, name, "spoolss_SetJob");
19680         ndr->depth++;
19681         if (flags & NDR_SET_VALUES) {
19682                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19683         }
19684         if (flags & NDR_IN) {
19685                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
19686                 ndr->depth++;
19687                 ndr_print_ptr(ndr, "handle", r->in.handle);
19688                 ndr->depth++;
19689                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19690                 ndr->depth--;
19691                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19692                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
19693                 ndr->depth++;
19694                 if (r->in.ctr) {
19695                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
19696                 }
19697                 ndr->depth--;
19698                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
19699                 ndr->depth--;
19700         }
19701         if (flags & NDR_OUT) {
19702                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
19703                 ndr->depth++;
19704                 ndr_print_WERROR(ndr, "result", r->out.result);
19705                 ndr->depth--;
19706         }
19707         ndr->depth--;
19708 }
19709
19710 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
19711 {
19712         if (flags & NDR_IN) {
19713                 if (r->in.handle == NULL) {
19714                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19715                 }
19716                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19717                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
19718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19719                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19720                 if (r->in.buffer) {
19721                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19722                 }
19723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19724         }
19725         if (flags & NDR_OUT) {
19726                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19727                 if (r->out.info) {
19728                         {
19729                                 struct ndr_push *_ndr_info;
19730                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19731                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19732                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19733                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19734                         }
19735                 }
19736                 if (r->out.needed == NULL) {
19737                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19738                 }
19739                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19740                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19741         }
19742         return NDR_ERR_SUCCESS;
19743 }
19744
19745 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
19746 {
19747         uint32_t _ptr_buffer;
19748         uint32_t _ptr_info;
19749         TALLOC_CTX *_mem_save_handle_0;
19750         TALLOC_CTX *_mem_save_buffer_0;
19751         TALLOC_CTX *_mem_save_info_0;
19752         TALLOC_CTX *_mem_save_needed_0;
19753         if (flags & NDR_IN) {
19754                 ZERO_STRUCT(r->out);
19755
19756                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19757                         NDR_PULL_ALLOC(ndr, r->in.handle);
19758                 }
19759                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19760                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19761                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19762                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
19764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19765                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19766                 if (_ptr_buffer) {
19767                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19768                 } else {
19769                         r->in.buffer = NULL;
19770                 }
19771                 if (r->in.buffer) {
19772                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19773                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19774                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19775                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19776                 }
19777                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19778                 NDR_PULL_ALLOC(ndr, r->out.needed);
19779                 ZERO_STRUCTP(r->out.needed);
19780         }
19781         if (flags & NDR_OUT) {
19782                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19783                 if (_ptr_info) {
19784                         NDR_PULL_ALLOC(ndr, r->out.info);
19785                 } else {
19786                         r->out.info = NULL;
19787                 }
19788                 if (r->out.info) {
19789                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19790                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19791                         {
19792                                 struct ndr_pull *_ndr_info;
19793                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19794                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19795                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19796                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19797                         }
19798                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19799                 }
19800                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19801                         NDR_PULL_ALLOC(ndr, r->out.needed);
19802                 }
19803                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19804                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19805                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19806                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19807                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19808         }
19809         return NDR_ERR_SUCCESS;
19810 }
19811
19812 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
19813 {
19814         ndr_print_struct(ndr, name, "spoolss_GetJob");
19815         ndr->depth++;
19816         if (flags & NDR_SET_VALUES) {
19817                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19818         }
19819         if (flags & NDR_IN) {
19820                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
19821                 ndr->depth++;
19822                 ndr_print_ptr(ndr, "handle", r->in.handle);
19823                 ndr->depth++;
19824                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19825                 ndr->depth--;
19826                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19827                 ndr_print_uint32(ndr, "level", r->in.level);
19828                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19829                 ndr->depth++;
19830                 if (r->in.buffer) {
19831                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19832                 }
19833                 ndr->depth--;
19834                 ndr_print_uint32(ndr, "offered", r->in.offered);
19835                 ndr->depth--;
19836         }
19837         if (flags & NDR_OUT) {
19838                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
19839                 ndr->depth++;
19840                 ndr_print_ptr(ndr, "info", r->out.info);
19841                 ndr->depth++;
19842                 if (r->out.info) {
19843                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19844                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
19845                 }
19846                 ndr->depth--;
19847                 ndr_print_ptr(ndr, "needed", r->out.needed);
19848                 ndr->depth++;
19849                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19850                 ndr->depth--;
19851                 ndr_print_WERROR(ndr, "result", r->out.result);
19852                 ndr->depth--;
19853         }
19854         ndr->depth--;
19855 }
19856
19857 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
19858 {
19859         if (flags & NDR_IN) {
19860                 if (r->in.handle == NULL) {
19861                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19862                 }
19863                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
19865                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
19866                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19867                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19868                 if (r->in.buffer) {
19869                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19870                 }
19871                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19872         }
19873         if (flags & NDR_OUT) {
19874                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19875                 if (r->out.info) {
19876                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19877                 }
19878                 if (r->out.needed == NULL) {
19879                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19880                 }
19881                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19882                 if (r->out.count == NULL) {
19883                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19884                 }
19885                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19886                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19887         }
19888         return NDR_ERR_SUCCESS;
19889 }
19890
19891 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
19892 {
19893         uint32_t _ptr_buffer;
19894         uint32_t _ptr_info;
19895         TALLOC_CTX *_mem_save_handle_0;
19896         TALLOC_CTX *_mem_save_buffer_0;
19897         TALLOC_CTX *_mem_save_info_0;
19898         TALLOC_CTX *_mem_save_needed_0;
19899         TALLOC_CTX *_mem_save_count_0;
19900         if (flags & NDR_IN) {
19901                 ZERO_STRUCT(r->out);
19902
19903                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19904                         NDR_PULL_ALLOC(ndr, r->in.handle);
19905                 }
19906                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19907                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19908                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19909                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19910                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
19911                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
19912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19913                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19914                 if (_ptr_buffer) {
19915                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19916                 } else {
19917                         r->in.buffer = NULL;
19918                 }
19919                 if (r->in.buffer) {
19920                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19921                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19922                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19923                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19924                 }
19925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19926                 NDR_PULL_ALLOC(ndr, r->out.needed);
19927                 ZERO_STRUCTP(r->out.needed);
19928                 NDR_PULL_ALLOC(ndr, r->out.count);
19929                 ZERO_STRUCTP(r->out.count);
19930         }
19931         if (flags & NDR_OUT) {
19932                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19933                 if (_ptr_info) {
19934                         NDR_PULL_ALLOC(ndr, r->out.info);
19935                 } else {
19936                         r->out.info = NULL;
19937                 }
19938                 if (r->out.info) {
19939                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19940                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19941                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19942                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19943                 }
19944                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19945                         NDR_PULL_ALLOC(ndr, r->out.needed);
19946                 }
19947                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19948                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19949                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19950                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19951                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19952                         NDR_PULL_ALLOC(ndr, r->out.count);
19953                 }
19954                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19955                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19956                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19957                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19958                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19959         }
19960         return NDR_ERR_SUCCESS;
19961 }
19962
19963 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
19964 {
19965         uint32_t cntr_info_0;
19966         if (flags & NDR_IN) {
19967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19969         }
19970         if (flags & NDR_OUT) {
19971                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19972                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19973                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19974                 }
19975                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19976                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19977                 }
19978         }
19979         return NDR_ERR_SUCCESS;
19980 }
19981
19982 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
19983 {
19984         uint32_t cntr_info_0;
19985         TALLOC_CTX *_mem_save_info_0;
19986         if (flags & NDR_IN) {
19987                 ZERO_STRUCT(r->out);
19988
19989                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19990                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19991         }
19992         if (flags & NDR_OUT) {
19993                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19994                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19995                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19996                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19997                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19998                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19999                 }
20000                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20001                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20002                 }
20003                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20004         }
20005         return NDR_ERR_SUCCESS;
20006 }
20007
20008 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
20009 {
20010         uint32_t cntr_info_2;
20011         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
20012         ndr->depth++;
20013         if (flags & NDR_SET_VALUES) {
20014                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20015         }
20016         if (flags & NDR_IN) {
20017                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
20018                 ndr->depth++;
20019                 ndr_print_ptr(ndr, "handle", r->in.handle);
20020                 ndr->depth++;
20021                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20022                 ndr->depth--;
20023                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
20024                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
20025                 ndr_print_uint32(ndr, "level", r->in.level);
20026                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20027                 ndr->depth++;
20028                 if (r->in.buffer) {
20029                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20030                 }
20031                 ndr->depth--;
20032                 ndr_print_uint32(ndr, "offered", r->in.offered);
20033                 ndr->depth--;
20034         }
20035         if (flags & NDR_OUT) {
20036                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
20037                 ndr->depth++;
20038                 ndr_print_ptr(ndr, "count", r->out.count);
20039                 ndr->depth++;
20040                 ndr_print_uint32(ndr, "count", *r->out.count);
20041                 ndr->depth--;
20042                 ndr_print_ptr(ndr, "info", r->out.info);
20043                 ndr->depth++;
20044                 ndr_print_ptr(ndr, "info", *r->out.info);
20045                 ndr->depth++;
20046                 if (*r->out.info) {
20047                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20048                         ndr->depth++;
20049                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20050                                 char *idx_2=NULL;
20051                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20052                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20053                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20054                                         free(idx_2);
20055                                 }
20056                         }
20057                         ndr->depth--;
20058                 }
20059                 ndr->depth--;
20060                 ndr->depth--;
20061                 ndr_print_ptr(ndr, "needed", r->out.needed);
20062                 ndr->depth++;
20063                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20064                 ndr->depth--;
20065                 ndr_print_WERROR(ndr, "result", r->out.result);
20066                 ndr->depth--;
20067         }
20068         ndr->depth--;
20069 }
20070
20071 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
20072 {
20073         if (flags & NDR_IN) {
20074                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20075                 if (r->in.server) {
20076                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20077                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20078                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20079                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20080                 }
20081                 if (r->in.info_ctr == NULL) {
20082                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20083                 }
20084                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20085                 if (r->in.devmode_ctr == NULL) {
20086                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20087                 }
20088                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20089                 if (r->in.secdesc_ctr == NULL) {
20090                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20091                 }
20092                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20093         }
20094         if (flags & NDR_OUT) {
20095                 if (r->out.handle == NULL) {
20096                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20097                 }
20098                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20099                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20100         }
20101         return NDR_ERR_SUCCESS;
20102 }
20103
20104 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
20105 {
20106         uint32_t _ptr_server;
20107         TALLOC_CTX *_mem_save_server_0;
20108         TALLOC_CTX *_mem_save_info_ctr_0;
20109         TALLOC_CTX *_mem_save_devmode_ctr_0;
20110         TALLOC_CTX *_mem_save_secdesc_ctr_0;
20111         TALLOC_CTX *_mem_save_handle_0;
20112         if (flags & NDR_IN) {
20113                 ZERO_STRUCT(r->out);
20114
20115                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20116                 if (_ptr_server) {
20117                         NDR_PULL_ALLOC(ndr, r->in.server);
20118                 } else {
20119                         r->in.server = NULL;
20120                 }
20121                 if (r->in.server) {
20122                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20123                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20124                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20125                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20126                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20127                                 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));
20128                         }
20129                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20130                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20131                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20132                 }
20133                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20134                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20135                 }
20136                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20137                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20138                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20139                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20140                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20141                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
20142                 }
20143                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20144                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
20145                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20146                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20147                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20148                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
20149                 }
20150                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20151                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
20152                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20153                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20154                 NDR_PULL_ALLOC(ndr, r->out.handle);
20155                 ZERO_STRUCTP(r->out.handle);
20156         }
20157         if (flags & NDR_OUT) {
20158                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20159                         NDR_PULL_ALLOC(ndr, r->out.handle);
20160                 }
20161                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20162                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20163                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20164                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20165                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20166         }
20167         return NDR_ERR_SUCCESS;
20168 }
20169
20170 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
20171 {
20172         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
20173         ndr->depth++;
20174         if (flags & NDR_SET_VALUES) {
20175                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20176         }
20177         if (flags & NDR_IN) {
20178                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
20179                 ndr->depth++;
20180                 ndr_print_ptr(ndr, "server", r->in.server);
20181                 ndr->depth++;
20182                 if (r->in.server) {
20183                         ndr_print_string(ndr, "server", r->in.server);
20184                 }
20185                 ndr->depth--;
20186                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
20187                 ndr->depth++;
20188                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
20189                 ndr->depth--;
20190                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
20191                 ndr->depth++;
20192                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
20193                 ndr->depth--;
20194                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20195                 ndr->depth++;
20196                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20197                 ndr->depth--;
20198                 ndr->depth--;
20199         }
20200         if (flags & NDR_OUT) {
20201                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
20202                 ndr->depth++;
20203                 ndr_print_ptr(ndr, "handle", r->out.handle);
20204                 ndr->depth++;
20205                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20206                 ndr->depth--;
20207                 ndr_print_WERROR(ndr, "result", r->out.result);
20208                 ndr->depth--;
20209         }
20210         ndr->depth--;
20211 }
20212
20213 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
20214 {
20215         if (flags & NDR_IN) {
20216                 if (r->in.handle == NULL) {
20217                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20218                 }
20219                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20220         }
20221         if (flags & NDR_OUT) {
20222                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20223         }
20224         return NDR_ERR_SUCCESS;
20225 }
20226
20227 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
20228 {
20229         TALLOC_CTX *_mem_save_handle_0;
20230         if (flags & NDR_IN) {
20231                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20232                         NDR_PULL_ALLOC(ndr, r->in.handle);
20233                 }
20234                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20235                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20236                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20237                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20238         }
20239         if (flags & NDR_OUT) {
20240                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20241         }
20242         return NDR_ERR_SUCCESS;
20243 }
20244
20245 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
20246 {
20247         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
20248         ndr->depth++;
20249         if (flags & NDR_SET_VALUES) {
20250                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20251         }
20252         if (flags & NDR_IN) {
20253                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
20254                 ndr->depth++;
20255                 ndr_print_ptr(ndr, "handle", r->in.handle);
20256                 ndr->depth++;
20257                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20258                 ndr->depth--;
20259                 ndr->depth--;
20260         }
20261         if (flags & NDR_OUT) {
20262                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
20263                 ndr->depth++;
20264                 ndr_print_WERROR(ndr, "result", r->out.result);
20265                 ndr->depth--;
20266         }
20267         ndr->depth--;
20268 }
20269
20270 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
20271 {
20272         if (flags & NDR_IN) {
20273                 if (r->in.handle == NULL) {
20274                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20275                 }
20276                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20277                 if (r->in.info_ctr == NULL) {
20278                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20279                 }
20280                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20281                 if (r->in.devmode_ctr == NULL) {
20282                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20283                 }
20284                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20285                 if (r->in.secdesc_ctr == NULL) {
20286                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20287                 }
20288                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20289                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
20290         }
20291         if (flags & NDR_OUT) {
20292                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20293         }
20294         return NDR_ERR_SUCCESS;
20295 }
20296
20297 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
20298 {
20299         TALLOC_CTX *_mem_save_handle_0;
20300         TALLOC_CTX *_mem_save_info_ctr_0;
20301         TALLOC_CTX *_mem_save_devmode_ctr_0;
20302         TALLOC_CTX *_mem_save_secdesc_ctr_0;
20303         if (flags & NDR_IN) {
20304                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20305                         NDR_PULL_ALLOC(ndr, r->in.handle);
20306                 }
20307                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20308                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20309                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20310                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20311                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20312                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20313                 }
20314                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20315                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20316                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20317                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20318                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20319                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
20320                 }
20321                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20322                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
20323                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20324                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20325                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20326                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
20327                 }
20328                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20329                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
20330                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20331                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20332                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
20333         }
20334         if (flags & NDR_OUT) {
20335                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20336         }
20337         return NDR_ERR_SUCCESS;
20338 }
20339
20340 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
20341 {
20342         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
20343         ndr->depth++;
20344         if (flags & NDR_SET_VALUES) {
20345                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20346         }
20347         if (flags & NDR_IN) {
20348                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
20349                 ndr->depth++;
20350                 ndr_print_ptr(ndr, "handle", r->in.handle);
20351                 ndr->depth++;
20352                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20353                 ndr->depth--;
20354                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
20355                 ndr->depth++;
20356                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
20357                 ndr->depth--;
20358                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
20359                 ndr->depth++;
20360                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
20361                 ndr->depth--;
20362                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20363                 ndr->depth++;
20364                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20365                 ndr->depth--;
20366                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
20367                 ndr->depth--;
20368         }
20369         if (flags & NDR_OUT) {
20370                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
20371                 ndr->depth++;
20372                 ndr_print_WERROR(ndr, "result", r->out.result);
20373                 ndr->depth--;
20374         }
20375         ndr->depth--;
20376 }
20377
20378 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
20379 {
20380         if (flags & NDR_IN) {
20381                 if (r->in.handle == NULL) {
20382                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20383                 }
20384                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20386                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20387                 if (r->in.buffer) {
20388                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20389                 }
20390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20391         }
20392         if (flags & NDR_OUT) {
20393                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20394                 if (r->out.info) {
20395                         {
20396                                 struct ndr_push *_ndr_info;
20397                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20398                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20399                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20400                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20401                         }
20402                 }
20403                 if (r->out.needed == NULL) {
20404                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20405                 }
20406                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20407                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20408         }
20409         return NDR_ERR_SUCCESS;
20410 }
20411
20412 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
20413 {
20414         uint32_t _ptr_buffer;
20415         uint32_t _ptr_info;
20416         TALLOC_CTX *_mem_save_handle_0;
20417         TALLOC_CTX *_mem_save_buffer_0;
20418         TALLOC_CTX *_mem_save_info_0;
20419         TALLOC_CTX *_mem_save_needed_0;
20420         if (flags & NDR_IN) {
20421                 ZERO_STRUCT(r->out);
20422
20423                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20424                         NDR_PULL_ALLOC(ndr, r->in.handle);
20425                 }
20426                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20427                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20428                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20429                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20431                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20432                 if (_ptr_buffer) {
20433                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20434                 } else {
20435                         r->in.buffer = NULL;
20436                 }
20437                 if (r->in.buffer) {
20438                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20439                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20440                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20441                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20442                 }
20443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20444                 NDR_PULL_ALLOC(ndr, r->out.needed);
20445                 ZERO_STRUCTP(r->out.needed);
20446         }
20447         if (flags & NDR_OUT) {
20448                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20449                 if (_ptr_info) {
20450                         NDR_PULL_ALLOC(ndr, r->out.info);
20451                 } else {
20452                         r->out.info = NULL;
20453                 }
20454                 if (r->out.info) {
20455                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20456                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20457                         {
20458                                 struct ndr_pull *_ndr_info;
20459                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20460                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20461                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20462                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20463                         }
20464                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20465                 }
20466                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20467                         NDR_PULL_ALLOC(ndr, r->out.needed);
20468                 }
20469                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20470                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20471                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20472                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20473                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20474         }
20475         return NDR_ERR_SUCCESS;
20476 }
20477
20478 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
20479 {
20480         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
20481         ndr->depth++;
20482         if (flags & NDR_SET_VALUES) {
20483                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20484         }
20485         if (flags & NDR_IN) {
20486                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
20487                 ndr->depth++;
20488                 ndr_print_ptr(ndr, "handle", r->in.handle);
20489                 ndr->depth++;
20490                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20491                 ndr->depth--;
20492                 ndr_print_uint32(ndr, "level", r->in.level);
20493                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20494                 ndr->depth++;
20495                 if (r->in.buffer) {
20496                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20497                 }
20498                 ndr->depth--;
20499                 ndr_print_uint32(ndr, "offered", r->in.offered);
20500                 ndr->depth--;
20501         }
20502         if (flags & NDR_OUT) {
20503                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
20504                 ndr->depth++;
20505                 ndr_print_ptr(ndr, "info", r->out.info);
20506                 ndr->depth++;
20507                 if (r->out.info) {
20508                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20509                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
20510                 }
20511                 ndr->depth--;
20512                 ndr_print_ptr(ndr, "needed", r->out.needed);
20513                 ndr->depth++;
20514                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20515                 ndr->depth--;
20516                 ndr_print_WERROR(ndr, "result", r->out.result);
20517                 ndr->depth--;
20518         }
20519         ndr->depth--;
20520 }
20521
20522 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
20523 {
20524         if (flags & NDR_IN) {
20525                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20526                 if (r->in.servername) {
20527                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20528                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20529                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20530                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20531                 }
20532                 if (r->in.info_ctr == NULL) {
20533                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20534                 }
20535                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20536         }
20537         if (flags & NDR_OUT) {
20538                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20539         }
20540         return NDR_ERR_SUCCESS;
20541 }
20542
20543 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
20544 {
20545         uint32_t _ptr_servername;
20546         TALLOC_CTX *_mem_save_servername_0;
20547         TALLOC_CTX *_mem_save_info_ctr_0;
20548         if (flags & NDR_IN) {
20549                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20550                 if (_ptr_servername) {
20551                         NDR_PULL_ALLOC(ndr, r->in.servername);
20552                 } else {
20553                         r->in.servername = NULL;
20554                 }
20555                 if (r->in.servername) {
20556                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20557                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20558                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20559                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20560                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20561                                 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));
20562                         }
20563                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20564                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20565                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20566                 }
20567                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20568                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20569                 }
20570                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20571                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20572                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20573                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20574         }
20575         if (flags & NDR_OUT) {
20576                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20577         }
20578         return NDR_ERR_SUCCESS;
20579 }
20580
20581 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
20582 {
20583         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
20584         ndr->depth++;
20585         if (flags & NDR_SET_VALUES) {
20586                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20587         }
20588         if (flags & NDR_IN) {
20589                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
20590                 ndr->depth++;
20591                 ndr_print_ptr(ndr, "servername", r->in.servername);
20592                 ndr->depth++;
20593                 if (r->in.servername) {
20594                         ndr_print_string(ndr, "servername", r->in.servername);
20595                 }
20596                 ndr->depth--;
20597                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
20598                 ndr->depth++;
20599                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
20600                 ndr->depth--;
20601                 ndr->depth--;
20602         }
20603         if (flags & NDR_OUT) {
20604                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
20605                 ndr->depth++;
20606                 ndr_print_WERROR(ndr, "result", r->out.result);
20607                 ndr->depth--;
20608         }
20609         ndr->depth--;
20610 }
20611
20612 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
20613 {
20614         if (flags & NDR_IN) {
20615                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20616                 if (r->in.server) {
20617                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20618                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20619                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20620                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20621                 }
20622                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20623                 if (r->in.environment) {
20624                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20625                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20626                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20627                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20628                 }
20629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20630                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20631                 if (r->in.buffer) {
20632                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20633                 }
20634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20635         }
20636         if (flags & NDR_OUT) {
20637                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20638                 if (r->out.info) {
20639                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20640                 }
20641                 if (r->out.needed == NULL) {
20642                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20643                 }
20644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20645                 if (r->out.count == NULL) {
20646                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20647                 }
20648                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20649                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20650         }
20651         return NDR_ERR_SUCCESS;
20652 }
20653
20654 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
20655 {
20656         uint32_t _ptr_server;
20657         uint32_t _ptr_environment;
20658         uint32_t _ptr_buffer;
20659         uint32_t _ptr_info;
20660         TALLOC_CTX *_mem_save_server_0;
20661         TALLOC_CTX *_mem_save_environment_0;
20662         TALLOC_CTX *_mem_save_buffer_0;
20663         TALLOC_CTX *_mem_save_info_0;
20664         TALLOC_CTX *_mem_save_needed_0;
20665         TALLOC_CTX *_mem_save_count_0;
20666         if (flags & NDR_IN) {
20667                 ZERO_STRUCT(r->out);
20668
20669                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20670                 if (_ptr_server) {
20671                         NDR_PULL_ALLOC(ndr, r->in.server);
20672                 } else {
20673                         r->in.server = NULL;
20674                 }
20675                 if (r->in.server) {
20676                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20677                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20678                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20679                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20680                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20681                                 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));
20682                         }
20683                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20684                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20685                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20686                 }
20687                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20688                 if (_ptr_environment) {
20689                         NDR_PULL_ALLOC(ndr, r->in.environment);
20690                 } else {
20691                         r->in.environment = NULL;
20692                 }
20693                 if (r->in.environment) {
20694                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20695                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20696                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20697                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20698                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20699                                 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));
20700                         }
20701                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20702                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20703                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20704                 }
20705                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20706                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20707                 if (_ptr_buffer) {
20708                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20709                 } else {
20710                         r->in.buffer = NULL;
20711                 }
20712                 if (r->in.buffer) {
20713                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20714                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20715                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20716                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20717                 }
20718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20719                 NDR_PULL_ALLOC(ndr, r->out.needed);
20720                 ZERO_STRUCTP(r->out.needed);
20721                 NDR_PULL_ALLOC(ndr, r->out.count);
20722                 ZERO_STRUCTP(r->out.count);
20723         }
20724         if (flags & NDR_OUT) {
20725                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20726                 if (_ptr_info) {
20727                         NDR_PULL_ALLOC(ndr, r->out.info);
20728                 } else {
20729                         r->out.info = NULL;
20730                 }
20731                 if (r->out.info) {
20732                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20733                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20734                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20735                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20736                 }
20737                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20738                         NDR_PULL_ALLOC(ndr, r->out.needed);
20739                 }
20740                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20741                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20742                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20743                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20744                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20745                         NDR_PULL_ALLOC(ndr, r->out.count);
20746                 }
20747                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20748                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20749                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20750                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20751                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20752         }
20753         return NDR_ERR_SUCCESS;
20754 }
20755
20756 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
20757 {
20758         uint32_t cntr_info_0;
20759         if (flags & NDR_IN) {
20760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20762         }
20763         if (flags & NDR_OUT) {
20764                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20765                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20766                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20767                 }
20768                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20769                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20770                 }
20771         }
20772         return NDR_ERR_SUCCESS;
20773 }
20774
20775 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
20776 {
20777         uint32_t cntr_info_0;
20778         TALLOC_CTX *_mem_save_info_0;
20779         if (flags & NDR_IN) {
20780                 ZERO_STRUCT(r->out);
20781
20782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20784         }
20785         if (flags & NDR_OUT) {
20786                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20787                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20788                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20789                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20790                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20791                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20792                 }
20793                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20794                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20795                 }
20796                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20797         }
20798         return NDR_ERR_SUCCESS;
20799 }
20800
20801 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
20802 {
20803         uint32_t cntr_info_2;
20804         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
20805         ndr->depth++;
20806         if (flags & NDR_SET_VALUES) {
20807                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20808         }
20809         if (flags & NDR_IN) {
20810                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
20811                 ndr->depth++;
20812                 ndr_print_ptr(ndr, "server", r->in.server);
20813                 ndr->depth++;
20814                 if (r->in.server) {
20815                         ndr_print_string(ndr, "server", r->in.server);
20816                 }
20817                 ndr->depth--;
20818                 ndr_print_ptr(ndr, "environment", r->in.environment);
20819                 ndr->depth++;
20820                 if (r->in.environment) {
20821                         ndr_print_string(ndr, "environment", r->in.environment);
20822                 }
20823                 ndr->depth--;
20824                 ndr_print_uint32(ndr, "level", r->in.level);
20825                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20826                 ndr->depth++;
20827                 if (r->in.buffer) {
20828                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20829                 }
20830                 ndr->depth--;
20831                 ndr_print_uint32(ndr, "offered", r->in.offered);
20832                 ndr->depth--;
20833         }
20834         if (flags & NDR_OUT) {
20835                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
20836                 ndr->depth++;
20837                 ndr_print_ptr(ndr, "count", r->out.count);
20838                 ndr->depth++;
20839                 ndr_print_uint32(ndr, "count", *r->out.count);
20840                 ndr->depth--;
20841                 ndr_print_ptr(ndr, "info", r->out.info);
20842                 ndr->depth++;
20843                 ndr_print_ptr(ndr, "info", *r->out.info);
20844                 ndr->depth++;
20845                 if (*r->out.info) {
20846                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20847                         ndr->depth++;
20848                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20849                                 char *idx_2=NULL;
20850                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20851                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20852                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20853                                         free(idx_2);
20854                                 }
20855                         }
20856                         ndr->depth--;
20857                 }
20858                 ndr->depth--;
20859                 ndr->depth--;
20860                 ndr_print_ptr(ndr, "needed", r->out.needed);
20861                 ndr->depth++;
20862                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20863                 ndr->depth--;
20864                 ndr_print_WERROR(ndr, "result", r->out.result);
20865                 ndr->depth--;
20866         }
20867         ndr->depth--;
20868 }
20869
20870 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
20871 {
20872         if (flags & NDR_IN) {
20873                 if (r->in.handle == NULL) {
20874                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20875                 }
20876                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20877                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
20878                 if (r->in.architecture) {
20879                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20880                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20881                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20882                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20883                 }
20884                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20885                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20886                 if (r->in.buffer) {
20887                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20888                 }
20889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20890         }
20891         if (flags & NDR_OUT) {
20892                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20893                 if (r->out.info) {
20894                         {
20895                                 struct ndr_push *_ndr_info;
20896                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20897                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20898                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20899                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20900                         }
20901                 }
20902                 if (r->out.needed == NULL) {
20903                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20904                 }
20905                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20906                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20907         }
20908         return NDR_ERR_SUCCESS;
20909 }
20910
20911 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
20912 {
20913         uint32_t _ptr_architecture;
20914         uint32_t _ptr_buffer;
20915         uint32_t _ptr_info;
20916         TALLOC_CTX *_mem_save_handle_0;
20917         TALLOC_CTX *_mem_save_architecture_0;
20918         TALLOC_CTX *_mem_save_buffer_0;
20919         TALLOC_CTX *_mem_save_info_0;
20920         TALLOC_CTX *_mem_save_needed_0;
20921         if (flags & NDR_IN) {
20922                 ZERO_STRUCT(r->out);
20923
20924                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20925                         NDR_PULL_ALLOC(ndr, r->in.handle);
20926                 }
20927                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20928                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20929                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20930                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20931                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
20932                 if (_ptr_architecture) {
20933                         NDR_PULL_ALLOC(ndr, r->in.architecture);
20934                 } else {
20935                         r->in.architecture = NULL;
20936                 }
20937                 if (r->in.architecture) {
20938                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
20939                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
20940                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20941                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20942                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20943                                 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));
20944                         }
20945                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20946                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20947                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
20948                 }
20949                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20950                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20951                 if (_ptr_buffer) {
20952                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20953                 } else {
20954                         r->in.buffer = NULL;
20955                 }
20956                 if (r->in.buffer) {
20957                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20958                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20959                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20960                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20961                 }
20962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20963                 NDR_PULL_ALLOC(ndr, r->out.needed);
20964                 ZERO_STRUCTP(r->out.needed);
20965         }
20966         if (flags & NDR_OUT) {
20967                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20968                 if (_ptr_info) {
20969                         NDR_PULL_ALLOC(ndr, r->out.info);
20970                 } else {
20971                         r->out.info = NULL;
20972                 }
20973                 if (r->out.info) {
20974                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20975                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20976                         {
20977                                 struct ndr_pull *_ndr_info;
20978                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20979                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20980                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20981                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20982                         }
20983                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20984                 }
20985                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20986                         NDR_PULL_ALLOC(ndr, r->out.needed);
20987                 }
20988                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20989                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20990                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20991                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20992                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20993         }
20994         return NDR_ERR_SUCCESS;
20995 }
20996
20997 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
20998 {
20999         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
21000         ndr->depth++;
21001         if (flags & NDR_SET_VALUES) {
21002                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21003         }
21004         if (flags & NDR_IN) {
21005                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
21006                 ndr->depth++;
21007                 ndr_print_ptr(ndr, "handle", r->in.handle);
21008                 ndr->depth++;
21009                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21010                 ndr->depth--;
21011                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
21012                 ndr->depth++;
21013                 if (r->in.architecture) {
21014                         ndr_print_string(ndr, "architecture", r->in.architecture);
21015                 }
21016                 ndr->depth--;
21017                 ndr_print_uint32(ndr, "level", r->in.level);
21018                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21019                 ndr->depth++;
21020                 if (r->in.buffer) {
21021                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21022                 }
21023                 ndr->depth--;
21024                 ndr_print_uint32(ndr, "offered", r->in.offered);
21025                 ndr->depth--;
21026         }
21027         if (flags & NDR_OUT) {
21028                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
21029                 ndr->depth++;
21030                 ndr_print_ptr(ndr, "info", r->out.info);
21031                 ndr->depth++;
21032                 if (r->out.info) {
21033                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21034                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
21035                 }
21036                 ndr->depth--;
21037                 ndr_print_ptr(ndr, "needed", r->out.needed);
21038                 ndr->depth++;
21039                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21040                 ndr->depth--;
21041                 ndr_print_WERROR(ndr, "result", r->out.result);
21042                 ndr->depth--;
21043         }
21044         ndr->depth--;
21045 }
21046
21047 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
21048 {
21049         if (flags & NDR_IN) {
21050                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21051                 if (r->in.server) {
21052                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21055                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21056                 }
21057                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21058                 if (r->in.environment) {
21059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21060                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21062                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21063                 }
21064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21065                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21066                 if (r->in.buffer) {
21067                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21068                 }
21069                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21070         }
21071         if (flags & NDR_OUT) {
21072                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21073                 if (r->out.info) {
21074                         {
21075                                 struct ndr_push *_ndr_info;
21076                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21077                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21078                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21079                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21080                         }
21081                 }
21082                 if (r->out.needed == NULL) {
21083                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21084                 }
21085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21086                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21087         }
21088         return NDR_ERR_SUCCESS;
21089 }
21090
21091 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
21092 {
21093         uint32_t _ptr_server;
21094         uint32_t _ptr_environment;
21095         uint32_t _ptr_buffer;
21096         uint32_t _ptr_info;
21097         TALLOC_CTX *_mem_save_server_0;
21098         TALLOC_CTX *_mem_save_environment_0;
21099         TALLOC_CTX *_mem_save_buffer_0;
21100         TALLOC_CTX *_mem_save_info_0;
21101         TALLOC_CTX *_mem_save_needed_0;
21102         if (flags & NDR_IN) {
21103                 ZERO_STRUCT(r->out);
21104
21105                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21106                 if (_ptr_server) {
21107                         NDR_PULL_ALLOC(ndr, r->in.server);
21108                 } else {
21109                         r->in.server = NULL;
21110                 }
21111                 if (r->in.server) {
21112                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21113                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21114                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21115                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21116                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21117                                 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));
21118                         }
21119                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21120                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21121                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21122                 }
21123                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21124                 if (_ptr_environment) {
21125                         NDR_PULL_ALLOC(ndr, r->in.environment);
21126                 } else {
21127                         r->in.environment = NULL;
21128                 }
21129                 if (r->in.environment) {
21130                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21131                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21132                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21133                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21134                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21135                                 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));
21136                         }
21137                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21138                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21139                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21140                 }
21141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21142                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21143                 if (_ptr_buffer) {
21144                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21145                 } else {
21146                         r->in.buffer = NULL;
21147                 }
21148                 if (r->in.buffer) {
21149                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21150                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21151                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21152                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21153                 }
21154                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21155                 NDR_PULL_ALLOC(ndr, r->out.needed);
21156                 ZERO_STRUCTP(r->out.needed);
21157         }
21158         if (flags & NDR_OUT) {
21159                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21160                 if (_ptr_info) {
21161                         NDR_PULL_ALLOC(ndr, r->out.info);
21162                 } else {
21163                         r->out.info = NULL;
21164                 }
21165                 if (r->out.info) {
21166                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21167                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21168                         {
21169                                 struct ndr_pull *_ndr_info;
21170                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21171                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21172                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21173                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21174                         }
21175                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21176                 }
21177                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21178                         NDR_PULL_ALLOC(ndr, r->out.needed);
21179                 }
21180                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21181                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21182                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21183                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21184                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21185         }
21186         return NDR_ERR_SUCCESS;
21187 }
21188
21189 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
21190 {
21191         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
21192         ndr->depth++;
21193         if (flags & NDR_SET_VALUES) {
21194                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21195         }
21196         if (flags & NDR_IN) {
21197                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
21198                 ndr->depth++;
21199                 ndr_print_ptr(ndr, "server", r->in.server);
21200                 ndr->depth++;
21201                 if (r->in.server) {
21202                         ndr_print_string(ndr, "server", r->in.server);
21203                 }
21204                 ndr->depth--;
21205                 ndr_print_ptr(ndr, "environment", r->in.environment);
21206                 ndr->depth++;
21207                 if (r->in.environment) {
21208                         ndr_print_string(ndr, "environment", r->in.environment);
21209                 }
21210                 ndr->depth--;
21211                 ndr_print_uint32(ndr, "level", r->in.level);
21212                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21213                 ndr->depth++;
21214                 if (r->in.buffer) {
21215                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21216                 }
21217                 ndr->depth--;
21218                 ndr_print_uint32(ndr, "offered", r->in.offered);
21219                 ndr->depth--;
21220         }
21221         if (flags & NDR_OUT) {
21222                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
21223                 ndr->depth++;
21224                 ndr_print_ptr(ndr, "info", r->out.info);
21225                 ndr->depth++;
21226                 if (r->out.info) {
21227                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21228                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
21229                 }
21230                 ndr->depth--;
21231                 ndr_print_ptr(ndr, "needed", r->out.needed);
21232                 ndr->depth++;
21233                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21234                 ndr->depth--;
21235                 ndr_print_WERROR(ndr, "result", r->out.result);
21236                 ndr->depth--;
21237         }
21238         ndr->depth--;
21239 }
21240
21241 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
21242 {
21243         if (flags & NDR_IN) {
21244                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21245                 if (r->in.server) {
21246                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21247                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21249                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21250                 }
21251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21254                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
21256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
21258                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21259         }
21260         if (flags & NDR_OUT) {
21261                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21262         }
21263         return NDR_ERR_SUCCESS;
21264 }
21265
21266 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
21267 {
21268         uint32_t _ptr_server;
21269         TALLOC_CTX *_mem_save_server_0;
21270         if (flags & NDR_IN) {
21271                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21272                 if (_ptr_server) {
21273                         NDR_PULL_ALLOC(ndr, r->in.server);
21274                 } else {
21275                         r->in.server = NULL;
21276                 }
21277                 if (r->in.server) {
21278                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21279                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21280                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21281                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21282                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21283                                 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));
21284                         }
21285                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21286                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21288                 }
21289                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
21290                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
21291                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
21292                         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));
21293                 }
21294                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
21295                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
21296                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
21297                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
21298                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
21299                         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));
21300                 }
21301                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
21302                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
21303         }
21304         if (flags & NDR_OUT) {
21305                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21306         }
21307         return NDR_ERR_SUCCESS;
21308 }
21309
21310 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
21311 {
21312         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
21313         ndr->depth++;
21314         if (flags & NDR_SET_VALUES) {
21315                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21316         }
21317         if (flags & NDR_IN) {
21318                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
21319                 ndr->depth++;
21320                 ndr_print_ptr(ndr, "server", r->in.server);
21321                 ndr->depth++;
21322                 if (r->in.server) {
21323                         ndr_print_string(ndr, "server", r->in.server);
21324                 }
21325                 ndr->depth--;
21326                 ndr_print_string(ndr, "architecture", r->in.architecture);
21327                 ndr_print_string(ndr, "driver", r->in.driver);
21328                 ndr->depth--;
21329         }
21330         if (flags & NDR_OUT) {
21331                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
21332                 ndr->depth++;
21333                 ndr_print_WERROR(ndr, "result", r->out.result);
21334                 ndr->depth--;
21335         }
21336         ndr->depth--;
21337 }
21338
21339 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
21340 {
21341         if (flags & NDR_IN) {
21342                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21343                 if (r->in.server) {
21344                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21345                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21346                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21347                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21348                 }
21349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21352                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
21354                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21355                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
21356                 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));
21357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
21358                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
21360                 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));
21361         }
21362         if (flags & NDR_OUT) {
21363                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21364         }
21365         return NDR_ERR_SUCCESS;
21366 }
21367
21368 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
21369 {
21370         uint32_t _ptr_server;
21371         TALLOC_CTX *_mem_save_server_0;
21372         if (flags & NDR_IN) {
21373                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21374                 if (_ptr_server) {
21375                         NDR_PULL_ALLOC(ndr, r->in.server);
21376                 } else {
21377                         r->in.server = NULL;
21378                 }
21379                 if (r->in.server) {
21380                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21381                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21382                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21383                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21384                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21385                                 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));
21386                         }
21387                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21388                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21389                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21390                 }
21391                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
21392                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
21393                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
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.architecture), ndr_get_array_length(ndr, &r->in.architecture));
21395                 }
21396                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
21397                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
21398                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
21399                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
21400                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
21401                         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));
21402                 }
21403                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
21404                 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));
21405                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
21406                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
21407                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
21408                         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));
21409                 }
21410                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
21411                 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));
21412         }
21413         if (flags & NDR_OUT) {
21414                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21415         }
21416         return NDR_ERR_SUCCESS;
21417 }
21418
21419 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
21420 {
21421         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
21422         ndr->depth++;
21423         if (flags & NDR_SET_VALUES) {
21424                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21425         }
21426         if (flags & NDR_IN) {
21427                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
21428                 ndr->depth++;
21429                 ndr_print_ptr(ndr, "server", r->in.server);
21430                 ndr->depth++;
21431                 if (r->in.server) {
21432                         ndr_print_string(ndr, "server", r->in.server);
21433                 }
21434                 ndr->depth--;
21435                 ndr_print_string(ndr, "architecture", r->in.architecture);
21436                 ndr_print_string(ndr, "path_name", r->in.path_name);
21437                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
21438                 ndr->depth--;
21439         }
21440         if (flags & NDR_OUT) {
21441                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
21442                 ndr->depth++;
21443                 ndr_print_WERROR(ndr, "result", r->out.result);
21444                 ndr->depth--;
21445         }
21446         ndr->depth--;
21447 }
21448
21449 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
21450 {
21451         if (flags & NDR_IN) {
21452                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
21453                 if (r->in.servername) {
21454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21455                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21456                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21457                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21458                 }
21459                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21460                 if (r->in.environment) {
21461                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21462                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21463                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21464                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21465                 }
21466                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21467                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21468                 if (r->in.buffer) {
21469                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21470                 }
21471                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21472         }
21473         if (flags & NDR_OUT) {
21474                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21475                 if (r->out.info) {
21476                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
21477                 }
21478                 if (r->out.needed == NULL) {
21479                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21480                 }
21481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21482                 if (r->out.count == NULL) {
21483                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21484                 }
21485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21486                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21487         }
21488         return NDR_ERR_SUCCESS;
21489 }
21490
21491 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
21492 {
21493         uint32_t _ptr_servername;
21494         uint32_t _ptr_environment;
21495         uint32_t _ptr_buffer;
21496         uint32_t _ptr_info;
21497         TALLOC_CTX *_mem_save_servername_0;
21498         TALLOC_CTX *_mem_save_environment_0;
21499         TALLOC_CTX *_mem_save_buffer_0;
21500         TALLOC_CTX *_mem_save_info_0;
21501         TALLOC_CTX *_mem_save_needed_0;
21502         TALLOC_CTX *_mem_save_count_0;
21503         if (flags & NDR_IN) {
21504                 ZERO_STRUCT(r->out);
21505
21506                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
21507                 if (_ptr_servername) {
21508                         NDR_PULL_ALLOC(ndr, r->in.servername);
21509                 } else {
21510                         r->in.servername = NULL;
21511                 }
21512                 if (r->in.servername) {
21513                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
21514                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
21515                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
21516                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
21517                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
21518                                 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));
21519                         }
21520                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
21521                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
21522                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
21523                 }
21524                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21525                 if (_ptr_environment) {
21526                         NDR_PULL_ALLOC(ndr, r->in.environment);
21527                 } else {
21528                         r->in.environment = NULL;
21529                 }
21530                 if (r->in.environment) {
21531                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21532                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21533                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21534                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21535                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21536                                 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));
21537                         }
21538                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21539                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21540                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21541                 }
21542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21543                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21544                 if (_ptr_buffer) {
21545                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21546                 } else {
21547                         r->in.buffer = NULL;
21548                 }
21549                 if (r->in.buffer) {
21550                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21551                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21552                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21553                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21554                 }
21555                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21556                 NDR_PULL_ALLOC(ndr, r->out.needed);
21557                 ZERO_STRUCTP(r->out.needed);
21558                 NDR_PULL_ALLOC(ndr, r->out.count);
21559                 ZERO_STRUCTP(r->out.count);
21560         }
21561         if (flags & NDR_OUT) {
21562                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21563                 if (_ptr_info) {
21564                         NDR_PULL_ALLOC(ndr, r->out.info);
21565                 } else {
21566                         r->out.info = NULL;
21567                 }
21568                 if (r->out.info) {
21569                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21570                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21571                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
21572                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21573                 }
21574                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21575                         NDR_PULL_ALLOC(ndr, r->out.needed);
21576                 }
21577                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21578                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21579                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21580                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21581                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21582                         NDR_PULL_ALLOC(ndr, r->out.count);
21583                 }
21584                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21585                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21586                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21587                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21588                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21589         }
21590         return NDR_ERR_SUCCESS;
21591 }
21592
21593 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
21594 {
21595         uint32_t cntr_info_0;
21596         if (flags & NDR_IN) {
21597                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
21599         }
21600         if (flags & NDR_OUT) {
21601                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21602                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21603                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21604                 }
21605                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21606                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21607                 }
21608         }
21609         return NDR_ERR_SUCCESS;
21610 }
21611
21612 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
21613 {
21614         uint32_t cntr_info_0;
21615         TALLOC_CTX *_mem_save_info_0;
21616         if (flags & NDR_IN) {
21617                 ZERO_STRUCT(r->out);
21618
21619                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21621         }
21622         if (flags & NDR_OUT) {
21623                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
21624                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21625                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21626                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21627                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21628                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21629                 }
21630                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21631                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21632                 }
21633                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21634         }
21635         return NDR_ERR_SUCCESS;
21636 }
21637
21638 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
21639 {
21640         uint32_t cntr_info_2;
21641         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
21642         ndr->depth++;
21643         if (flags & NDR_SET_VALUES) {
21644                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21645         }
21646         if (flags & NDR_IN) {
21647                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
21648                 ndr->depth++;
21649                 ndr_print_ptr(ndr, "servername", r->in.servername);
21650                 ndr->depth++;
21651                 if (r->in.servername) {
21652                         ndr_print_string(ndr, "servername", r->in.servername);
21653                 }
21654                 ndr->depth--;
21655                 ndr_print_ptr(ndr, "environment", r->in.environment);
21656                 ndr->depth++;
21657                 if (r->in.environment) {
21658                         ndr_print_string(ndr, "environment", r->in.environment);
21659                 }
21660                 ndr->depth--;
21661                 ndr_print_uint32(ndr, "level", r->in.level);
21662                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21663                 ndr->depth++;
21664                 if (r->in.buffer) {
21665                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21666                 }
21667                 ndr->depth--;
21668                 ndr_print_uint32(ndr, "offered", r->in.offered);
21669                 ndr->depth--;
21670         }
21671         if (flags & NDR_OUT) {
21672                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
21673                 ndr->depth++;
21674                 ndr_print_ptr(ndr, "count", r->out.count);
21675                 ndr->depth++;
21676                 ndr_print_uint32(ndr, "count", *r->out.count);
21677                 ndr->depth--;
21678                 ndr_print_ptr(ndr, "info", r->out.info);
21679                 ndr->depth++;
21680                 ndr_print_ptr(ndr, "info", *r->out.info);
21681                 ndr->depth++;
21682                 if (*r->out.info) {
21683                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21684                         ndr->depth++;
21685                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21686                                 char *idx_2=NULL;
21687                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21688                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21689                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21690                                         free(idx_2);
21691                                 }
21692                         }
21693                         ndr->depth--;
21694                 }
21695                 ndr->depth--;
21696                 ndr->depth--;
21697                 ndr_print_ptr(ndr, "needed", r->out.needed);
21698                 ndr->depth++;
21699                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21700                 ndr->depth--;
21701                 ndr_print_WERROR(ndr, "result", r->out.result);
21702                 ndr->depth--;
21703         }
21704         ndr->depth--;
21705 }
21706
21707 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
21708 {
21709         if (flags & NDR_IN) {
21710                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21711                 if (r->in.server) {
21712                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21713                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21714                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21715                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21716                 }
21717                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21718                 if (r->in.environment) {
21719                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21720                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21721                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21722                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21723                 }
21724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21725                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21726                 if (r->in.buffer) {
21727                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21728                 }
21729                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21730         }
21731         if (flags & NDR_OUT) {
21732                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21733                 if (r->out.info) {
21734                         {
21735                                 struct ndr_push *_ndr_info;
21736                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21737                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21738                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21739                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21740                         }
21741                 }
21742                 if (r->out.needed == NULL) {
21743                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21744                 }
21745                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21746                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21747         }
21748         return NDR_ERR_SUCCESS;
21749 }
21750
21751 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
21752 {
21753         uint32_t _ptr_server;
21754         uint32_t _ptr_environment;
21755         uint32_t _ptr_buffer;
21756         uint32_t _ptr_info;
21757         TALLOC_CTX *_mem_save_server_0;
21758         TALLOC_CTX *_mem_save_environment_0;
21759         TALLOC_CTX *_mem_save_buffer_0;
21760         TALLOC_CTX *_mem_save_info_0;
21761         TALLOC_CTX *_mem_save_needed_0;
21762         if (flags & NDR_IN) {
21763                 ZERO_STRUCT(r->out);
21764
21765                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21766                 if (_ptr_server) {
21767                         NDR_PULL_ALLOC(ndr, r->in.server);
21768                 } else {
21769                         r->in.server = NULL;
21770                 }
21771                 if (r->in.server) {
21772                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21773                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21774                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21775                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21776                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21777                                 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));
21778                         }
21779                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21780                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21781                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21782                 }
21783                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21784                 if (_ptr_environment) {
21785                         NDR_PULL_ALLOC(ndr, r->in.environment);
21786                 } else {
21787                         r->in.environment = NULL;
21788                 }
21789                 if (r->in.environment) {
21790                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21791                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21792                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21793                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21794                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21795                                 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));
21796                         }
21797                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21798                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21799                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21800                 }
21801                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21802                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21803                 if (_ptr_buffer) {
21804                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21805                 } else {
21806                         r->in.buffer = NULL;
21807                 }
21808                 if (r->in.buffer) {
21809                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21810                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21811                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21812                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21813                 }
21814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21815                 NDR_PULL_ALLOC(ndr, r->out.needed);
21816                 ZERO_STRUCTP(r->out.needed);
21817         }
21818         if (flags & NDR_OUT) {
21819                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21820                 if (_ptr_info) {
21821                         NDR_PULL_ALLOC(ndr, r->out.info);
21822                 } else {
21823                         r->out.info = NULL;
21824                 }
21825                 if (r->out.info) {
21826                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21827                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21828                         {
21829                                 struct ndr_pull *_ndr_info;
21830                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21831                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21832                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21833                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21834                         }
21835                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21836                 }
21837                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21838                         NDR_PULL_ALLOC(ndr, r->out.needed);
21839                 }
21840                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21841                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21843                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21844                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21845         }
21846         return NDR_ERR_SUCCESS;
21847 }
21848
21849 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
21850 {
21851         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
21852         ndr->depth++;
21853         if (flags & NDR_SET_VALUES) {
21854                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21855         }
21856         if (flags & NDR_IN) {
21857                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
21858                 ndr->depth++;
21859                 ndr_print_ptr(ndr, "server", r->in.server);
21860                 ndr->depth++;
21861                 if (r->in.server) {
21862                         ndr_print_string(ndr, "server", r->in.server);
21863                 }
21864                 ndr->depth--;
21865                 ndr_print_ptr(ndr, "environment", r->in.environment);
21866                 ndr->depth++;
21867                 if (r->in.environment) {
21868                         ndr_print_string(ndr, "environment", r->in.environment);
21869                 }
21870                 ndr->depth--;
21871                 ndr_print_uint32(ndr, "level", r->in.level);
21872                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21873                 ndr->depth++;
21874                 if (r->in.buffer) {
21875                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21876                 }
21877                 ndr->depth--;
21878                 ndr_print_uint32(ndr, "offered", r->in.offered);
21879                 ndr->depth--;
21880         }
21881         if (flags & NDR_OUT) {
21882                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
21883                 ndr->depth++;
21884                 ndr_print_ptr(ndr, "info", r->out.info);
21885                 ndr->depth++;
21886                 if (r->out.info) {
21887                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21888                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
21889                 }
21890                 ndr->depth--;
21891                 ndr_print_ptr(ndr, "needed", r->out.needed);
21892                 ndr->depth++;
21893                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21894                 ndr->depth--;
21895                 ndr_print_WERROR(ndr, "result", r->out.result);
21896                 ndr->depth--;
21897         }
21898         ndr->depth--;
21899 }
21900
21901 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
21902 {
21903         if (flags & NDR_IN) {
21904                 if (r->in.handle == NULL) {
21905                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21906                 }
21907                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21909                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
21910                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21911         }
21912         if (flags & NDR_OUT) {
21913                 if (r->out.job_id == NULL) {
21914                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21915                 }
21916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
21917                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21918         }
21919         return NDR_ERR_SUCCESS;
21920 }
21921
21922 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
21923 {
21924         TALLOC_CTX *_mem_save_handle_0;
21925         TALLOC_CTX *_mem_save_job_id_0;
21926         if (flags & NDR_IN) {
21927                 ZERO_STRUCT(r->out);
21928
21929                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21930                         NDR_PULL_ALLOC(ndr, r->in.handle);
21931                 }
21932                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21933                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21934                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21935                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21936                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21937                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
21938                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21939                 NDR_PULL_ALLOC(ndr, r->out.job_id);
21940                 ZERO_STRUCTP(r->out.job_id);
21941         }
21942         if (flags & NDR_OUT) {
21943                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21944                         NDR_PULL_ALLOC(ndr, r->out.job_id);
21945                 }
21946                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
21947                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
21948                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
21949                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
21950                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21951         }
21952         return NDR_ERR_SUCCESS;
21953 }
21954
21955 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
21956 {
21957         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
21958         ndr->depth++;
21959         if (flags & NDR_SET_VALUES) {
21960                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21961         }
21962         if (flags & NDR_IN) {
21963                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
21964                 ndr->depth++;
21965                 ndr_print_ptr(ndr, "handle", r->in.handle);
21966                 ndr->depth++;
21967                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21968                 ndr->depth--;
21969                 ndr_print_uint32(ndr, "level", r->in.level);
21970                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
21971                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
21972                 ndr->depth--;
21973         }
21974         if (flags & NDR_OUT) {
21975                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
21976                 ndr->depth++;
21977                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
21978                 ndr->depth++;
21979                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
21980                 ndr->depth--;
21981                 ndr_print_WERROR(ndr, "result", r->out.result);
21982                 ndr->depth--;
21983         }
21984         ndr->depth--;
21985 }
21986
21987 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
21988 {
21989         if (flags & NDR_IN) {
21990                 if (r->in.handle == NULL) {
21991                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21992                 }
21993                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21994         }
21995         if (flags & NDR_OUT) {
21996                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21997         }
21998         return NDR_ERR_SUCCESS;
21999 }
22000
22001 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
22002 {
22003         TALLOC_CTX *_mem_save_handle_0;
22004         if (flags & NDR_IN) {
22005                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22006                         NDR_PULL_ALLOC(ndr, r->in.handle);
22007                 }
22008                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22009                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22010                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22011                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22012         }
22013         if (flags & NDR_OUT) {
22014                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22015         }
22016         return NDR_ERR_SUCCESS;
22017 }
22018
22019 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
22020 {
22021         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
22022         ndr->depth++;
22023         if (flags & NDR_SET_VALUES) {
22024                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22025         }
22026         if (flags & NDR_IN) {
22027                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
22028                 ndr->depth++;
22029                 ndr_print_ptr(ndr, "handle", r->in.handle);
22030                 ndr->depth++;
22031                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22032                 ndr->depth--;
22033                 ndr->depth--;
22034         }
22035         if (flags & NDR_OUT) {
22036                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
22037                 ndr->depth++;
22038                 ndr_print_WERROR(ndr, "result", r->out.result);
22039                 ndr->depth--;
22040         }
22041         ndr->depth--;
22042 }
22043
22044 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
22045 {
22046         if (flags & NDR_IN) {
22047                 if (r->in.handle == NULL) {
22048                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22049                 }
22050                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22051                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
22052                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
22053         }
22054         if (flags & NDR_OUT) {
22055                 if (r->out.num_written == NULL) {
22056                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22057                 }
22058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
22059                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22060         }
22061         return NDR_ERR_SUCCESS;
22062 }
22063
22064 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
22065 {
22066         TALLOC_CTX *_mem_save_handle_0;
22067         TALLOC_CTX *_mem_save_num_written_0;
22068         if (flags & NDR_IN) {
22069                 ZERO_STRUCT(r->out);
22070
22071                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22072                         NDR_PULL_ALLOC(ndr, r->in.handle);
22073                 }
22074                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22075                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22076                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22077                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22078                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
22079                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
22080                 NDR_PULL_ALLOC(ndr, r->out.num_written);
22081                 ZERO_STRUCTP(r->out.num_written);
22082         }
22083         if (flags & NDR_OUT) {
22084                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22085                         NDR_PULL_ALLOC(ndr, r->out.num_written);
22086                 }
22087                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
22088                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
22089                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
22090                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
22091                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22092         }
22093         return NDR_ERR_SUCCESS;
22094 }
22095
22096 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
22097 {
22098         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
22099         ndr->depth++;
22100         if (flags & NDR_SET_VALUES) {
22101                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22102         }
22103         if (flags & NDR_IN) {
22104                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
22105                 ndr->depth++;
22106                 ndr_print_ptr(ndr, "handle", r->in.handle);
22107                 ndr->depth++;
22108                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22109                 ndr->depth--;
22110                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
22111                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
22112                 ndr->depth--;
22113         }
22114         if (flags & NDR_OUT) {
22115                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
22116                 ndr->depth++;
22117                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
22118                 ndr->depth++;
22119                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
22120                 ndr->depth--;
22121                 ndr_print_WERROR(ndr, "result", r->out.result);
22122                 ndr->depth--;
22123         }
22124         ndr->depth--;
22125 }
22126
22127 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
22128 {
22129         if (flags & NDR_IN) {
22130                 if (r->in.handle == NULL) {
22131                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22132                 }
22133                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22134         }
22135         if (flags & NDR_OUT) {
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_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
22142 {
22143         TALLOC_CTX *_mem_save_handle_0;
22144         if (flags & NDR_IN) {
22145                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22146                         NDR_PULL_ALLOC(ndr, r->in.handle);
22147                 }
22148                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22149                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22150                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22151                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22152         }
22153         if (flags & NDR_OUT) {
22154                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22155         }
22156         return NDR_ERR_SUCCESS;
22157 }
22158
22159 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
22160 {
22161         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
22162         ndr->depth++;
22163         if (flags & NDR_SET_VALUES) {
22164                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22165         }
22166         if (flags & NDR_IN) {
22167                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
22168                 ndr->depth++;
22169                 ndr_print_ptr(ndr, "handle", r->in.handle);
22170                 ndr->depth++;
22171                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22172                 ndr->depth--;
22173                 ndr->depth--;
22174         }
22175         if (flags & NDR_OUT) {
22176                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
22177                 ndr->depth++;
22178                 ndr_print_WERROR(ndr, "result", r->out.result);
22179                 ndr->depth--;
22180         }
22181         ndr->depth--;
22182 }
22183
22184 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
22185 {
22186         if (flags & NDR_IN) {
22187                 if (r->in.handle == NULL) {
22188                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22189                 }
22190                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22191         }
22192         if (flags & NDR_OUT) {
22193                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22194         }
22195         return NDR_ERR_SUCCESS;
22196 }
22197
22198 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
22199 {
22200         TALLOC_CTX *_mem_save_handle_0;
22201         if (flags & NDR_IN) {
22202                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22203                         NDR_PULL_ALLOC(ndr, r->in.handle);
22204                 }
22205                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22206                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22207                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22208                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22209         }
22210         if (flags & NDR_OUT) {
22211                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22212         }
22213         return NDR_ERR_SUCCESS;
22214 }
22215
22216 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
22217 {
22218         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
22219         ndr->depth++;
22220         if (flags & NDR_SET_VALUES) {
22221                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22222         }
22223         if (flags & NDR_IN) {
22224                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
22225                 ndr->depth++;
22226                 ndr_print_ptr(ndr, "handle", r->in.handle);
22227                 ndr->depth++;
22228                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22229                 ndr->depth--;
22230                 ndr->depth--;
22231         }
22232         if (flags & NDR_OUT) {
22233                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
22234                 ndr->depth++;
22235                 ndr_print_WERROR(ndr, "result", r->out.result);
22236                 ndr->depth--;
22237         }
22238         ndr->depth--;
22239 }
22240
22241 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
22242 {
22243         if (flags & NDR_IN) {
22244                 if (r->in.handle == NULL) {
22245                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22246                 }
22247                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
22249         }
22250         if (flags & NDR_OUT) {
22251                 if (r->out.data == NULL) {
22252                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22253                 }
22254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
22255                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
22256                 if (r->out._data_size == NULL) {
22257                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22258                 }
22259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
22260                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22261         }
22262         return NDR_ERR_SUCCESS;
22263 }
22264
22265 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
22266 {
22267         TALLOC_CTX *_mem_save_handle_0;
22268         TALLOC_CTX *_mem_save__data_size_0;
22269         if (flags & NDR_IN) {
22270                 ZERO_STRUCT(r->out);
22271
22272                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22273                         NDR_PULL_ALLOC(ndr, r->in.handle);
22274                 }
22275                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22276                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22277                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22278                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22279                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
22280                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
22281                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
22282                 NDR_PULL_ALLOC(ndr, r->out._data_size);
22283                 ZERO_STRUCTP(r->out._data_size);
22284         }
22285         if (flags & NDR_OUT) {
22286                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
22287                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22288                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
22289                 }
22290                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
22291                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22292                         NDR_PULL_ALLOC(ndr, r->out._data_size);
22293                 }
22294                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
22295                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
22296                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
22297                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
22298                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22299                 if (r->out.data) {
22300                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
22301                 }
22302         }
22303         return NDR_ERR_SUCCESS;
22304 }
22305
22306 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
22307 {
22308         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
22309         ndr->depth++;
22310         if (flags & NDR_SET_VALUES) {
22311                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22312         }
22313         if (flags & NDR_IN) {
22314                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
22315                 ndr->depth++;
22316                 ndr_print_ptr(ndr, "handle", r->in.handle);
22317                 ndr->depth++;
22318                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22319                 ndr->depth--;
22320                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
22321                 ndr->depth--;
22322         }
22323         if (flags & NDR_OUT) {
22324                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
22325                 ndr->depth++;
22326                 ndr_print_ptr(ndr, "data", r->out.data);
22327                 ndr->depth++;
22328                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
22329                 ndr->depth--;
22330                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
22331                 ndr->depth++;
22332                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
22333                 ndr->depth--;
22334                 ndr_print_WERROR(ndr, "result", r->out.result);
22335                 ndr->depth--;
22336         }
22337         ndr->depth--;
22338 }
22339
22340 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
22341 {
22342         if (flags & NDR_IN) {
22343                 if (r->in.handle == NULL) {
22344                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22345                 }
22346                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22347         }
22348         if (flags & NDR_OUT) {
22349                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22350         }
22351         return NDR_ERR_SUCCESS;
22352 }
22353
22354 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
22355 {
22356         TALLOC_CTX *_mem_save_handle_0;
22357         if (flags & NDR_IN) {
22358                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22359                         NDR_PULL_ALLOC(ndr, r->in.handle);
22360                 }
22361                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22362                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22363                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22364                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22365         }
22366         if (flags & NDR_OUT) {
22367                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22368         }
22369         return NDR_ERR_SUCCESS;
22370 }
22371
22372 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
22373 {
22374         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
22375         ndr->depth++;
22376         if (flags & NDR_SET_VALUES) {
22377                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22378         }
22379         if (flags & NDR_IN) {
22380                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
22381                 ndr->depth++;
22382                 ndr_print_ptr(ndr, "handle", r->in.handle);
22383                 ndr->depth++;
22384                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22385                 ndr->depth--;
22386                 ndr->depth--;
22387         }
22388         if (flags & NDR_OUT) {
22389                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
22390                 ndr->depth++;
22391                 ndr_print_WERROR(ndr, "result", r->out.result);
22392                 ndr->depth--;
22393         }
22394         ndr->depth--;
22395 }
22396
22397 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
22398 {
22399         if (flags & NDR_IN) {
22400                 if (r->in.handle == NULL) {
22401                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22402                 }
22403                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22405                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22406                 if (r->in.buffer) {
22407                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22408                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
22409                 }
22410                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22411         }
22412         if (flags & NDR_OUT) {
22413                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
22414                 if (r->out.buffer) {
22415                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22416                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
22417                 }
22418                 if (r->out.needed == NULL) {
22419                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22420                 }
22421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22422                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22423         }
22424         return NDR_ERR_SUCCESS;
22425 }
22426
22427 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
22428 {
22429         uint32_t _ptr_buffer;
22430         TALLOC_CTX *_mem_save_handle_0;
22431         TALLOC_CTX *_mem_save_buffer_0;
22432         TALLOC_CTX *_mem_save_needed_0;
22433         if (flags & NDR_IN) {
22434                 ZERO_STRUCT(r->out);
22435
22436                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22437                         NDR_PULL_ALLOC(ndr, r->in.handle);
22438                 }
22439                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22440                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22441                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22442                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22444                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22445                 if (_ptr_buffer) {
22446                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22447                 } else {
22448                         r->in.buffer = NULL;
22449                 }
22450                 if (r->in.buffer) {
22451                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22452                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22453                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
22454                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
22455                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
22456                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22457                 }
22458                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22459                 NDR_PULL_ALLOC(ndr, r->out.needed);
22460                 ZERO_STRUCTP(r->out.needed);
22461                 if (r->in.buffer) {
22462                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
22463                 }
22464         }
22465         if (flags & NDR_OUT) {
22466                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22467                 if (_ptr_buffer) {
22468                         NDR_PULL_ALLOC(ndr, r->out.buffer);
22469                 } else {
22470                         r->out.buffer = NULL;
22471                 }
22472                 if (r->out.buffer) {
22473                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22474                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
22475                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
22476                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
22477                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
22478                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22479                 }
22480                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22481                         NDR_PULL_ALLOC(ndr, r->out.needed);
22482                 }
22483                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22484                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22485                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22486                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22487                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22488                 if (r->out.buffer) {
22489                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
22490                 }
22491         }
22492         return NDR_ERR_SUCCESS;
22493 }
22494
22495 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
22496 {
22497         ndr_print_struct(ndr, name, "spoolss_AddJob");
22498         ndr->depth++;
22499         if (flags & NDR_SET_VALUES) {
22500                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22501         }
22502         if (flags & NDR_IN) {
22503                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
22504                 ndr->depth++;
22505                 ndr_print_ptr(ndr, "handle", r->in.handle);
22506                 ndr->depth++;
22507                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22508                 ndr->depth--;
22509                 ndr_print_uint32(ndr, "level", r->in.level);
22510                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22511                 ndr->depth++;
22512                 if (r->in.buffer) {
22513                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
22514                 }
22515                 ndr->depth--;
22516                 ndr_print_uint32(ndr, "offered", r->in.offered);
22517                 ndr->depth--;
22518         }
22519         if (flags & NDR_OUT) {
22520                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
22521                 ndr->depth++;
22522                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
22523                 ndr->depth++;
22524                 if (r->out.buffer) {
22525                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
22526                 }
22527                 ndr->depth--;
22528                 ndr_print_ptr(ndr, "needed", r->out.needed);
22529                 ndr->depth++;
22530                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22531                 ndr->depth--;
22532                 ndr_print_WERROR(ndr, "result", r->out.result);
22533                 ndr->depth--;
22534         }
22535         ndr->depth--;
22536 }
22537
22538 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
22539 {
22540         if (flags & NDR_IN) {
22541                 if (r->in.handle == NULL) {
22542                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22543                 }
22544                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
22546         }
22547         if (flags & NDR_OUT) {
22548                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22549         }
22550         return NDR_ERR_SUCCESS;
22551 }
22552
22553 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
22554 {
22555         TALLOC_CTX *_mem_save_handle_0;
22556         if (flags & NDR_IN) {
22557                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22558                         NDR_PULL_ALLOC(ndr, r->in.handle);
22559                 }
22560                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22561                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22562                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22563                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
22565         }
22566         if (flags & NDR_OUT) {
22567                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22568         }
22569         return NDR_ERR_SUCCESS;
22570 }
22571
22572 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
22573 {
22574         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
22575         ndr->depth++;
22576         if (flags & NDR_SET_VALUES) {
22577                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22578         }
22579         if (flags & NDR_IN) {
22580                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
22581                 ndr->depth++;
22582                 ndr_print_ptr(ndr, "handle", r->in.handle);
22583                 ndr->depth++;
22584                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22585                 ndr->depth--;
22586                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
22587                 ndr->depth--;
22588         }
22589         if (flags & NDR_OUT) {
22590                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
22591                 ndr->depth++;
22592                 ndr_print_WERROR(ndr, "result", r->out.result);
22593                 ndr->depth--;
22594         }
22595         ndr->depth--;
22596 }
22597
22598 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
22599 {
22600         if (flags & NDR_IN) {
22601                 if (r->in.handle == NULL) {
22602                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22603                 }
22604                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22607                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22608                 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));
22609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22610         }
22611         if (flags & NDR_OUT) {
22612                 if (r->out.type == NULL) {
22613                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22614                 }
22615                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
22616                 if (r->out.data == NULL) {
22617                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22618                 }
22619                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
22620                 if (r->out.needed == NULL) {
22621                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22622                 }
22623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22624                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22625         }
22626         return NDR_ERR_SUCCESS;
22627 }
22628
22629 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
22630 {
22631         TALLOC_CTX *_mem_save_handle_0;
22632         TALLOC_CTX *_mem_save_type_0;
22633         TALLOC_CTX *_mem_save_data_0;
22634         TALLOC_CTX *_mem_save_needed_0;
22635         if (flags & NDR_IN) {
22636                 ZERO_STRUCT(r->out);
22637
22638                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22639                         NDR_PULL_ALLOC(ndr, r->in.handle);
22640                 }
22641                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22642                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22643                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22644                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22645                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22646                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22647                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22648                         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));
22649                 }
22650                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22651                 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));
22652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22653                 NDR_PULL_ALLOC(ndr, r->out.type);
22654                 ZERO_STRUCTP(r->out.type);
22655                 NDR_PULL_ALLOC(ndr, r->out.data);
22656                 ZERO_STRUCTP(r->out.data);
22657                 NDR_PULL_ALLOC(ndr, r->out.needed);
22658                 ZERO_STRUCTP(r->out.needed);
22659         }
22660         if (flags & NDR_OUT) {
22661                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22662                         NDR_PULL_ALLOC(ndr, r->out.type);
22663                 }
22664                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
22665                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
22666                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
22667                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
22668                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22669                         NDR_PULL_ALLOC(ndr, r->out.data);
22670                 }
22671                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
22672                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
22673                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
22674                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
22675                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22676                         NDR_PULL_ALLOC(ndr, r->out.needed);
22677                 }
22678                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22679                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22680                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22681                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22682                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22683         }
22684         return NDR_ERR_SUCCESS;
22685 }
22686
22687 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
22688 {
22689         if (flags & NDR_IN) {
22690                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22691         }
22692         if (flags & NDR_OUT) {
22693                 if (r->out.data == NULL) {
22694                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22695                 }
22696                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
22697                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
22698         }
22699         return NDR_ERR_SUCCESS;
22700 }
22701
22702 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
22703 {
22704         TALLOC_CTX *_mem_save_data_0;
22705         if (flags & NDR_IN) {
22706                 ZERO_STRUCT(r->out);
22707
22708                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
22709                 NDR_PULL_ALLOC(ndr, r->out.data);
22710                 ZERO_STRUCTP(r->out.data);
22711         }
22712         if (flags & NDR_OUT) {
22713                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22714                         NDR_PULL_ALLOC(ndr, r->out.data);
22715                 }
22716                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
22717                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
22718                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
22719                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
22720                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
22721         }
22722         return NDR_ERR_SUCCESS;
22723 }
22724
22725 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
22726 {
22727         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
22728         ndr->depth++;
22729         if (flags & NDR_SET_VALUES) {
22730                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22731         }
22732         if (flags & NDR_IN) {
22733                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
22734                 ndr->depth++;
22735                 ndr_print_ptr(ndr, "handle", r->in.handle);
22736                 ndr->depth++;
22737                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22738                 ndr->depth--;
22739                 ndr_print_string(ndr, "value_name", r->in.value_name);
22740                 ndr_print_uint32(ndr, "offered", r->in.offered);
22741                 ndr->depth--;
22742         }
22743         if (flags & NDR_OUT) {
22744                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
22745                 ndr->depth++;
22746                 ndr_print_ptr(ndr, "type", r->out.type);
22747                 ndr->depth++;
22748                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
22749                 ndr->depth--;
22750                 ndr_print_ptr(ndr, "data", r->out.data);
22751                 ndr->depth++;
22752                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
22753                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
22754                 ndr->depth--;
22755                 ndr_print_ptr(ndr, "needed", r->out.needed);
22756                 ndr->depth++;
22757                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22758                 ndr->depth--;
22759                 ndr_print_WERROR(ndr, "result", r->out.result);
22760                 ndr->depth--;
22761         }
22762         ndr->depth--;
22763 }
22764
22765 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
22766 {
22767         if (flags & NDR_IN) {
22768                 if (r->in.handle == NULL) {
22769                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22770                 }
22771                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22772                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22775                 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));
22776                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22777                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
22778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
22779         }
22780         if (flags & NDR_OUT) {
22781                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22782         }
22783         return NDR_ERR_SUCCESS;
22784 }
22785
22786 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
22787 {
22788         if (flags & NDR_IN) {
22789                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22790         }
22791         if (flags & NDR_OUT) {
22792                 if (r->out.data == NULL) {
22793                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22794                 }
22795                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
22796                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
22797         }
22798         return NDR_ERR_SUCCESS;
22799 }
22800
22801 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
22802 {
22803         TALLOC_CTX *_mem_save_handle_0;
22804         if (flags & NDR_IN) {
22805                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22806                         NDR_PULL_ALLOC(ndr, r->in.handle);
22807                 }
22808                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22809                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22810                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22811                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22812                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22813                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22814                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22815                         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));
22816                 }
22817                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22818                 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));
22819                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
22820                 {
22821                         struct ndr_pull *_ndr_data;
22822                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
22823                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
22824                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
22825                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
22826                 }
22827                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
22828         }
22829         if (flags & NDR_OUT) {
22830                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22831         }
22832         return NDR_ERR_SUCCESS;
22833 }
22834
22835 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
22836 {
22837         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
22838         ndr->depth++;
22839         if (flags & NDR_SET_VALUES) {
22840                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22841         }
22842         if (flags & NDR_IN) {
22843                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
22844                 ndr->depth++;
22845                 ndr_print_ptr(ndr, "handle", r->in.handle);
22846                 ndr->depth++;
22847                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22848                 ndr->depth--;
22849                 ndr_print_string(ndr, "value_name", r->in.value_name);
22850                 ndr_print_winreg_Type(ndr, "type", r->in.type);
22851                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
22852                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
22853                 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);
22854                 ndr->depth--;
22855         }
22856         if (flags & NDR_OUT) {
22857                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
22858                 ndr->depth++;
22859                 ndr_print_WERROR(ndr, "result", r->out.result);
22860                 ndr->depth--;
22861         }
22862         ndr->depth--;
22863 }
22864
22865 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
22866 {
22867         if (flags & NDR_IN) {
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_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
22876 {
22877         if (flags & NDR_IN) {
22878         }
22879         if (flags & NDR_OUT) {
22880                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22881         }
22882         return NDR_ERR_SUCCESS;
22883 }
22884
22885 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
22886 {
22887         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
22888         ndr->depth++;
22889         if (flags & NDR_SET_VALUES) {
22890                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22891         }
22892         if (flags & NDR_IN) {
22893                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
22894                 ndr->depth++;
22895                 ndr->depth--;
22896         }
22897         if (flags & NDR_OUT) {
22898                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
22899                 ndr->depth++;
22900                 ndr_print_WERROR(ndr, "result", r->out.result);
22901                 ndr->depth--;
22902         }
22903         ndr->depth--;
22904 }
22905
22906 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
22907 {
22908         if (flags & NDR_IN) {
22909                 if (r->in.handle == NULL) {
22910                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22911                 }
22912                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22913         }
22914         if (flags & NDR_OUT) {
22915                 if (r->out.handle == NULL) {
22916                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22917                 }
22918                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
22919                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22920         }
22921         return NDR_ERR_SUCCESS;
22922 }
22923
22924 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
22925 {
22926         TALLOC_CTX *_mem_save_handle_0;
22927         if (flags & NDR_IN) {
22928                 ZERO_STRUCT(r->out);
22929
22930                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22931                         NDR_PULL_ALLOC(ndr, r->in.handle);
22932                 }
22933                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22934                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22935                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22936                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22937                 NDR_PULL_ALLOC(ndr, r->out.handle);
22938                 *r->out.handle = *r->in.handle;
22939         }
22940         if (flags & NDR_OUT) {
22941                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22942                         NDR_PULL_ALLOC(ndr, r->out.handle);
22943                 }
22944                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22945                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
22946                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
22947                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22948                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22949         }
22950         return NDR_ERR_SUCCESS;
22951 }
22952
22953 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
22954 {
22955         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
22956         ndr->depth++;
22957         if (flags & NDR_SET_VALUES) {
22958                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22959         }
22960         if (flags & NDR_IN) {
22961                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
22962                 ndr->depth++;
22963                 ndr_print_ptr(ndr, "handle", r->in.handle);
22964                 ndr->depth++;
22965                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22966                 ndr->depth--;
22967                 ndr->depth--;
22968         }
22969         if (flags & NDR_OUT) {
22970                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
22971                 ndr->depth++;
22972                 ndr_print_ptr(ndr, "handle", r->out.handle);
22973                 ndr->depth++;
22974                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
22975                 ndr->depth--;
22976                 ndr_print_WERROR(ndr, "result", r->out.result);
22977                 ndr->depth--;
22978         }
22979         ndr->depth--;
22980 }
22981
22982 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
22983 {
22984         if (flags & NDR_IN) {
22985                 if (r->in.handle == NULL) {
22986                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22987                 }
22988                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22990                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22991                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22992         }
22993         if (flags & NDR_OUT) {
22994                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22995         }
22996         return NDR_ERR_SUCCESS;
22997 }
22998
22999 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
23000 {
23001         TALLOC_CTX *_mem_save_handle_0;
23002         if (flags & NDR_IN) {
23003                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23004                         NDR_PULL_ALLOC(ndr, r->in.handle);
23005                 }
23006                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23007                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23008                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23009                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23011                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23012                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23013         }
23014         if (flags & NDR_OUT) {
23015                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23016         }
23017         return NDR_ERR_SUCCESS;
23018 }
23019
23020 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
23021 {
23022         ndr_print_struct(ndr, name, "spoolss_AddForm");
23023         ndr->depth++;
23024         if (flags & NDR_SET_VALUES) {
23025                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23026         }
23027         if (flags & NDR_IN) {
23028                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
23029                 ndr->depth++;
23030                 ndr_print_ptr(ndr, "handle", r->in.handle);
23031                 ndr->depth++;
23032                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23033                 ndr->depth--;
23034                 ndr_print_uint32(ndr, "level", r->in.level);
23035                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
23036                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
23037                 ndr->depth--;
23038         }
23039         if (flags & NDR_OUT) {
23040                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
23041                 ndr->depth++;
23042                 ndr_print_WERROR(ndr, "result", r->out.result);
23043                 ndr->depth--;
23044         }
23045         ndr->depth--;
23046 }
23047
23048 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
23049 {
23050         if (flags & NDR_IN) {
23051                 if (r->in.handle == NULL) {
23052                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23053                 }
23054                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23058                 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));
23059         }
23060         if (flags & NDR_OUT) {
23061                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23062         }
23063         return NDR_ERR_SUCCESS;
23064 }
23065
23066 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
23067 {
23068         TALLOC_CTX *_mem_save_handle_0;
23069         if (flags & NDR_IN) {
23070                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23071                         NDR_PULL_ALLOC(ndr, r->in.handle);
23072                 }
23073                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23074                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23075                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23076                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23077                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23078                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23079                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23080                         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));
23081                 }
23082                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23083                 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));
23084         }
23085         if (flags & NDR_OUT) {
23086                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23087         }
23088         return NDR_ERR_SUCCESS;
23089 }
23090
23091 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
23092 {
23093         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
23094         ndr->depth++;
23095         if (flags & NDR_SET_VALUES) {
23096                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23097         }
23098         if (flags & NDR_IN) {
23099                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
23100                 ndr->depth++;
23101                 ndr_print_ptr(ndr, "handle", r->in.handle);
23102                 ndr->depth++;
23103                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23104                 ndr->depth--;
23105                 ndr_print_string(ndr, "form_name", r->in.form_name);
23106                 ndr->depth--;
23107         }
23108         if (flags & NDR_OUT) {
23109                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
23110                 ndr->depth++;
23111                 ndr_print_WERROR(ndr, "result", r->out.result);
23112                 ndr->depth--;
23113         }
23114         ndr->depth--;
23115 }
23116
23117 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
23118 {
23119         if (flags & NDR_IN) {
23120                 if (r->in.handle == NULL) {
23121                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23122                 }
23123                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23124                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23125                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23126                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23127                 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));
23128                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23129                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23130                 if (r->in.buffer) {
23131                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23132                 }
23133                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23134         }
23135         if (flags & NDR_OUT) {
23136                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23137                 if (r->out.info) {
23138                         {
23139                                 struct ndr_push *_ndr_info;
23140                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23141                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
23142                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23143                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23144                         }
23145                 }
23146                 if (r->out.needed == NULL) {
23147                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23148                 }
23149                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23150                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23151         }
23152         return NDR_ERR_SUCCESS;
23153 }
23154
23155 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
23156 {
23157         uint32_t _ptr_buffer;
23158         uint32_t _ptr_info;
23159         TALLOC_CTX *_mem_save_handle_0;
23160         TALLOC_CTX *_mem_save_buffer_0;
23161         TALLOC_CTX *_mem_save_info_0;
23162         TALLOC_CTX *_mem_save_needed_0;
23163         if (flags & NDR_IN) {
23164                 ZERO_STRUCT(r->out);
23165
23166                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23167                         NDR_PULL_ALLOC(ndr, r->in.handle);
23168                 }
23169                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23170                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23171                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23172                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23173                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23174                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23175                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23176                         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));
23177                 }
23178                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23179                 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));
23180                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23181                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23182                 if (_ptr_buffer) {
23183                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23184                 } else {
23185                         r->in.buffer = NULL;
23186                 }
23187                 if (r->in.buffer) {
23188                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23189                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23190                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23192                 }
23193                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23194                 NDR_PULL_ALLOC(ndr, r->out.needed);
23195                 ZERO_STRUCTP(r->out.needed);
23196         }
23197         if (flags & NDR_OUT) {
23198                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23199                 if (_ptr_info) {
23200                         NDR_PULL_ALLOC(ndr, r->out.info);
23201                 } else {
23202                         r->out.info = NULL;
23203                 }
23204                 if (r->out.info) {
23205                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23206                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23207                         {
23208                                 struct ndr_pull *_ndr_info;
23209                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23210                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
23211                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23212                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23213                         }
23214                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23215                 }
23216                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23217                         NDR_PULL_ALLOC(ndr, r->out.needed);
23218                 }
23219                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23220                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23222                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23223                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23224         }
23225         return NDR_ERR_SUCCESS;
23226 }
23227
23228 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
23229 {
23230         ndr_print_struct(ndr, name, "spoolss_GetForm");
23231         ndr->depth++;
23232         if (flags & NDR_SET_VALUES) {
23233                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23234         }
23235         if (flags & NDR_IN) {
23236                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
23237                 ndr->depth++;
23238                 ndr_print_ptr(ndr, "handle", r->in.handle);
23239                 ndr->depth++;
23240                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23241                 ndr->depth--;
23242                 ndr_print_string(ndr, "form_name", r->in.form_name);
23243                 ndr_print_uint32(ndr, "level", r->in.level);
23244                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23245                 ndr->depth++;
23246                 if (r->in.buffer) {
23247                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23248                 }
23249                 ndr->depth--;
23250                 ndr_print_uint32(ndr, "offered", r->in.offered);
23251                 ndr->depth--;
23252         }
23253         if (flags & NDR_OUT) {
23254                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
23255                 ndr->depth++;
23256                 ndr_print_ptr(ndr, "info", r->out.info);
23257                 ndr->depth++;
23258                 if (r->out.info) {
23259                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
23260                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
23261                 }
23262                 ndr->depth--;
23263                 ndr_print_ptr(ndr, "needed", r->out.needed);
23264                 ndr->depth++;
23265                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23266                 ndr->depth--;
23267                 ndr_print_WERROR(ndr, "result", r->out.result);
23268                 ndr->depth--;
23269         }
23270         ndr->depth--;
23271 }
23272
23273 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
23274 {
23275         if (flags & NDR_IN) {
23276                 if (r->in.handle == NULL) {
23277                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23278                 }
23279                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23281                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23282                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23283                 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));
23284                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23285                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
23286                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23287         }
23288         if (flags & NDR_OUT) {
23289                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23290         }
23291         return NDR_ERR_SUCCESS;
23292 }
23293
23294 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
23295 {
23296         TALLOC_CTX *_mem_save_handle_0;
23297         if (flags & NDR_IN) {
23298                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23299                         NDR_PULL_ALLOC(ndr, r->in.handle);
23300                 }
23301                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23302                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23303                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23304                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23305                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23306                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23307                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23308                         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));
23309                 }
23310                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23311                 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));
23312                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23313                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23314                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23315         }
23316         if (flags & NDR_OUT) {
23317                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23318         }
23319         return NDR_ERR_SUCCESS;
23320 }
23321
23322 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
23323 {
23324         ndr_print_struct(ndr, name, "spoolss_SetForm");
23325         ndr->depth++;
23326         if (flags & NDR_SET_VALUES) {
23327                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23328         }
23329         if (flags & NDR_IN) {
23330                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
23331                 ndr->depth++;
23332                 ndr_print_ptr(ndr, "handle", r->in.handle);
23333                 ndr->depth++;
23334                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23335                 ndr->depth--;
23336                 ndr_print_string(ndr, "form_name", r->in.form_name);
23337                 ndr_print_uint32(ndr, "level", r->in.level);
23338                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
23339                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
23340                 ndr->depth--;
23341         }
23342         if (flags & NDR_OUT) {
23343                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
23344                 ndr->depth++;
23345                 ndr_print_WERROR(ndr, "result", r->out.result);
23346                 ndr->depth--;
23347         }
23348         ndr->depth--;
23349 }
23350
23351 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
23352 {
23353         if (flags & NDR_IN) {
23354                 if (r->in.handle == NULL) {
23355                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23356                 }
23357                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23358                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23359                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23360                 if (r->in.buffer) {
23361                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23362                 }
23363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23364         }
23365         if (flags & NDR_OUT) {
23366                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23367                 if (r->out.info) {
23368                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23369                 }
23370                 if (r->out.needed == NULL) {
23371                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23372                 }
23373                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23374                 if (r->out.count == NULL) {
23375                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23376                 }
23377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23378                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23379         }
23380         return NDR_ERR_SUCCESS;
23381 }
23382
23383 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
23384 {
23385         uint32_t _ptr_buffer;
23386         uint32_t _ptr_info;
23387         TALLOC_CTX *_mem_save_handle_0;
23388         TALLOC_CTX *_mem_save_buffer_0;
23389         TALLOC_CTX *_mem_save_info_0;
23390         TALLOC_CTX *_mem_save_needed_0;
23391         TALLOC_CTX *_mem_save_count_0;
23392         if (flags & NDR_IN) {
23393                 ZERO_STRUCT(r->out);
23394
23395                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23396                         NDR_PULL_ALLOC(ndr, r->in.handle);
23397                 }
23398                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23399                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23400                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23401                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23402                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23403                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23404                 if (_ptr_buffer) {
23405                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23406                 } else {
23407                         r->in.buffer = NULL;
23408                 }
23409                 if (r->in.buffer) {
23410                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23411                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23412                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23413                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23414                 }
23415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23416                 NDR_PULL_ALLOC(ndr, r->out.needed);
23417                 ZERO_STRUCTP(r->out.needed);
23418                 NDR_PULL_ALLOC(ndr, r->out.count);
23419                 ZERO_STRUCTP(r->out.count);
23420         }
23421         if (flags & NDR_OUT) {
23422                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23423                 if (_ptr_info) {
23424                         NDR_PULL_ALLOC(ndr, r->out.info);
23425                 } else {
23426                         r->out.info = NULL;
23427                 }
23428                 if (r->out.info) {
23429                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23430                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23431                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23432                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23433                 }
23434                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23435                         NDR_PULL_ALLOC(ndr, r->out.needed);
23436                 }
23437                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23438                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23440                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23441                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23442                         NDR_PULL_ALLOC(ndr, r->out.count);
23443                 }
23444                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23445                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23447                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23448                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23449         }
23450         return NDR_ERR_SUCCESS;
23451 }
23452
23453 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
23454 {
23455         uint32_t cntr_info_0;
23456         if (flags & NDR_IN) {
23457                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23459         }
23460         if (flags & NDR_OUT) {
23461                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23462                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23463                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23464                 }
23465                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23466                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23467                 }
23468         }
23469         return NDR_ERR_SUCCESS;
23470 }
23471
23472 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
23473 {
23474         uint32_t cntr_info_0;
23475         TALLOC_CTX *_mem_save_info_0;
23476         if (flags & NDR_IN) {
23477                 ZERO_STRUCT(r->out);
23478
23479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23480                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23481         }
23482         if (flags & NDR_OUT) {
23483                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23484                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23485                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23486                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23487                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23488                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23489                 }
23490                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23491                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23492                 }
23493                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23494         }
23495         return NDR_ERR_SUCCESS;
23496 }
23497
23498 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
23499 {
23500         uint32_t cntr_info_2;
23501         ndr_print_struct(ndr, name, "spoolss_EnumForms");
23502         ndr->depth++;
23503         if (flags & NDR_SET_VALUES) {
23504                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23505         }
23506         if (flags & NDR_IN) {
23507                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
23508                 ndr->depth++;
23509                 ndr_print_ptr(ndr, "handle", r->in.handle);
23510                 ndr->depth++;
23511                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23512                 ndr->depth--;
23513                 ndr_print_uint32(ndr, "level", r->in.level);
23514                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23515                 ndr->depth++;
23516                 if (r->in.buffer) {
23517                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23518                 }
23519                 ndr->depth--;
23520                 ndr_print_uint32(ndr, "offered", r->in.offered);
23521                 ndr->depth--;
23522         }
23523         if (flags & NDR_OUT) {
23524                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
23525                 ndr->depth++;
23526                 ndr_print_ptr(ndr, "count", r->out.count);
23527                 ndr->depth++;
23528                 ndr_print_uint32(ndr, "count", *r->out.count);
23529                 ndr->depth--;
23530                 ndr_print_ptr(ndr, "info", r->out.info);
23531                 ndr->depth++;
23532                 ndr_print_ptr(ndr, "info", *r->out.info);
23533                 ndr->depth++;
23534                 if (*r->out.info) {
23535                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23536                         ndr->depth++;
23537                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23538                                 char *idx_2=NULL;
23539                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23540                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23541                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23542                                         free(idx_2);
23543                                 }
23544                         }
23545                         ndr->depth--;
23546                 }
23547                 ndr->depth--;
23548                 ndr->depth--;
23549                 ndr_print_ptr(ndr, "needed", r->out.needed);
23550                 ndr->depth++;
23551                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23552                 ndr->depth--;
23553                 ndr_print_WERROR(ndr, "result", r->out.result);
23554                 ndr->depth--;
23555         }
23556         ndr->depth--;
23557 }
23558
23559 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
23560 {
23561         if (flags & NDR_IN) {
23562                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23563                 if (r->in.servername) {
23564                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23565                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23566                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23567                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23568                 }
23569                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23570                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23571                 if (r->in.buffer) {
23572                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23573                 }
23574                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23575         }
23576         if (flags & NDR_OUT) {
23577                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23578                 if (r->out.info) {
23579                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23580                 }
23581                 if (r->out.needed == NULL) {
23582                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23583                 }
23584                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23585                 if (r->out.count == NULL) {
23586                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23587                 }
23588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23589                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23590         }
23591         return NDR_ERR_SUCCESS;
23592 }
23593
23594 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
23595 {
23596         uint32_t _ptr_servername;
23597         uint32_t _ptr_buffer;
23598         uint32_t _ptr_info;
23599         TALLOC_CTX *_mem_save_servername_0;
23600         TALLOC_CTX *_mem_save_buffer_0;
23601         TALLOC_CTX *_mem_save_info_0;
23602         TALLOC_CTX *_mem_save_needed_0;
23603         TALLOC_CTX *_mem_save_count_0;
23604         if (flags & NDR_IN) {
23605                 ZERO_STRUCT(r->out);
23606
23607                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23608                 if (_ptr_servername) {
23609                         NDR_PULL_ALLOC(ndr, r->in.servername);
23610                 } else {
23611                         r->in.servername = NULL;
23612                 }
23613                 if (r->in.servername) {
23614                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23615                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23616                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23617                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23618                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23619                                 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));
23620                         }
23621                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23622                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23623                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23624                 }
23625                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23626                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23627                 if (_ptr_buffer) {
23628                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23629                 } else {
23630                         r->in.buffer = NULL;
23631                 }
23632                 if (r->in.buffer) {
23633                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23634                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23635                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23636                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23637                 }
23638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23639                 NDR_PULL_ALLOC(ndr, r->out.needed);
23640                 ZERO_STRUCTP(r->out.needed);
23641                 NDR_PULL_ALLOC(ndr, r->out.count);
23642                 ZERO_STRUCTP(r->out.count);
23643         }
23644         if (flags & NDR_OUT) {
23645                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23646                 if (_ptr_info) {
23647                         NDR_PULL_ALLOC(ndr, r->out.info);
23648                 } else {
23649                         r->out.info = NULL;
23650                 }
23651                 if (r->out.info) {
23652                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23653                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23654                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23655                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23656                 }
23657                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23658                         NDR_PULL_ALLOC(ndr, r->out.needed);
23659                 }
23660                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23661                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23662                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23663                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23664                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23665                         NDR_PULL_ALLOC(ndr, r->out.count);
23666                 }
23667                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23668                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23669                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23670                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23671                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23672         }
23673         return NDR_ERR_SUCCESS;
23674 }
23675
23676 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
23677 {
23678         uint32_t cntr_info_0;
23679         if (flags & NDR_IN) {
23680                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23681                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23682         }
23683         if (flags & NDR_OUT) {
23684                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23685                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23686                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23687                 }
23688                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23689                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23690                 }
23691         }
23692         return NDR_ERR_SUCCESS;
23693 }
23694
23695 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
23696 {
23697         uint32_t cntr_info_0;
23698         TALLOC_CTX *_mem_save_info_0;
23699         if (flags & NDR_IN) {
23700                 ZERO_STRUCT(r->out);
23701
23702                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23703                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23704         }
23705         if (flags & NDR_OUT) {
23706                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23707                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23708                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23709                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23710                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23711                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23712                 }
23713                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23714                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23715                 }
23716                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23717         }
23718         return NDR_ERR_SUCCESS;
23719 }
23720
23721 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
23722 {
23723         uint32_t cntr_info_2;
23724         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
23725         ndr->depth++;
23726         if (flags & NDR_SET_VALUES) {
23727                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23728         }
23729         if (flags & NDR_IN) {
23730                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
23731                 ndr->depth++;
23732                 ndr_print_ptr(ndr, "servername", r->in.servername);
23733                 ndr->depth++;
23734                 if (r->in.servername) {
23735                         ndr_print_string(ndr, "servername", r->in.servername);
23736                 }
23737                 ndr->depth--;
23738                 ndr_print_uint32(ndr, "level", r->in.level);
23739                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23740                 ndr->depth++;
23741                 if (r->in.buffer) {
23742                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23743                 }
23744                 ndr->depth--;
23745                 ndr_print_uint32(ndr, "offered", r->in.offered);
23746                 ndr->depth--;
23747         }
23748         if (flags & NDR_OUT) {
23749                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
23750                 ndr->depth++;
23751                 ndr_print_ptr(ndr, "count", r->out.count);
23752                 ndr->depth++;
23753                 ndr_print_uint32(ndr, "count", *r->out.count);
23754                 ndr->depth--;
23755                 ndr_print_ptr(ndr, "info", r->out.info);
23756                 ndr->depth++;
23757                 ndr_print_ptr(ndr, "info", *r->out.info);
23758                 ndr->depth++;
23759                 if (*r->out.info) {
23760                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23761                         ndr->depth++;
23762                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23763                                 char *idx_2=NULL;
23764                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23765                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23766                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23767                                         free(idx_2);
23768                                 }
23769                         }
23770                         ndr->depth--;
23771                 }
23772                 ndr->depth--;
23773                 ndr->depth--;
23774                 ndr_print_ptr(ndr, "needed", r->out.needed);
23775                 ndr->depth++;
23776                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23777                 ndr->depth--;
23778                 ndr_print_WERROR(ndr, "result", r->out.result);
23779                 ndr->depth--;
23780         }
23781         ndr->depth--;
23782 }
23783
23784 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
23785 {
23786         if (flags & NDR_IN) {
23787                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23788                 if (r->in.servername) {
23789                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23790                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23791                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23792                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23793                 }
23794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23795                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23796                 if (r->in.buffer) {
23797                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23798                 }
23799                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23800         }
23801         if (flags & NDR_OUT) {
23802                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23803                 if (r->out.info) {
23804                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23805                 }
23806                 if (r->out.needed == NULL) {
23807                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23808                 }
23809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23810                 if (r->out.count == NULL) {
23811                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23812                 }
23813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23814                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23815         }
23816         return NDR_ERR_SUCCESS;
23817 }
23818
23819 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
23820 {
23821         uint32_t _ptr_servername;
23822         uint32_t _ptr_buffer;
23823         uint32_t _ptr_info;
23824         TALLOC_CTX *_mem_save_servername_0;
23825         TALLOC_CTX *_mem_save_buffer_0;
23826         TALLOC_CTX *_mem_save_info_0;
23827         TALLOC_CTX *_mem_save_needed_0;
23828         TALLOC_CTX *_mem_save_count_0;
23829         if (flags & NDR_IN) {
23830                 ZERO_STRUCT(r->out);
23831
23832                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23833                 if (_ptr_servername) {
23834                         NDR_PULL_ALLOC(ndr, r->in.servername);
23835                 } else {
23836                         r->in.servername = NULL;
23837                 }
23838                 if (r->in.servername) {
23839                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23840                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23841                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23842                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23843                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23844                                 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));
23845                         }
23846                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23847                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23848                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23849                 }
23850                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23851                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23852                 if (_ptr_buffer) {
23853                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23854                 } else {
23855                         r->in.buffer = NULL;
23856                 }
23857                 if (r->in.buffer) {
23858                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23859                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23860                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23861                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23862                 }
23863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23864                 NDR_PULL_ALLOC(ndr, r->out.needed);
23865                 ZERO_STRUCTP(r->out.needed);
23866                 NDR_PULL_ALLOC(ndr, r->out.count);
23867                 ZERO_STRUCTP(r->out.count);
23868         }
23869         if (flags & NDR_OUT) {
23870                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23871                 if (_ptr_info) {
23872                         NDR_PULL_ALLOC(ndr, r->out.info);
23873                 } else {
23874                         r->out.info = NULL;
23875                 }
23876                 if (r->out.info) {
23877                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23878                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23879                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23880                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23881                 }
23882                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23883                         NDR_PULL_ALLOC(ndr, r->out.needed);
23884                 }
23885                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23886                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23887                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23888                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23889                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23890                         NDR_PULL_ALLOC(ndr, r->out.count);
23891                 }
23892                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23893                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23894                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23895                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23896                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23897         }
23898         return NDR_ERR_SUCCESS;
23899 }
23900
23901 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
23902 {
23903         uint32_t cntr_info_0;
23904         if (flags & NDR_IN) {
23905                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23906                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23907         }
23908         if (flags & NDR_OUT) {
23909                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23910                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23911                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23912                 }
23913                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23914                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23915                 }
23916         }
23917         return NDR_ERR_SUCCESS;
23918 }
23919
23920 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
23921 {
23922         uint32_t cntr_info_0;
23923         TALLOC_CTX *_mem_save_info_0;
23924         if (flags & NDR_IN) {
23925                 ZERO_STRUCT(r->out);
23926
23927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23928                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23929         }
23930         if (flags & NDR_OUT) {
23931                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23932                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23933                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23934                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23935                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23936                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23937                 }
23938                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23939                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23940                 }
23941                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23942         }
23943         return NDR_ERR_SUCCESS;
23944 }
23945
23946 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
23947 {
23948         uint32_t cntr_info_2;
23949         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
23950         ndr->depth++;
23951         if (flags & NDR_SET_VALUES) {
23952                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23953         }
23954         if (flags & NDR_IN) {
23955                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
23956                 ndr->depth++;
23957                 ndr_print_ptr(ndr, "servername", r->in.servername);
23958                 ndr->depth++;
23959                 if (r->in.servername) {
23960                         ndr_print_string(ndr, "servername", r->in.servername);
23961                 }
23962                 ndr->depth--;
23963                 ndr_print_uint32(ndr, "level", r->in.level);
23964                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23965                 ndr->depth++;
23966                 if (r->in.buffer) {
23967                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23968                 }
23969                 ndr->depth--;
23970                 ndr_print_uint32(ndr, "offered", r->in.offered);
23971                 ndr->depth--;
23972         }
23973         if (flags & NDR_OUT) {
23974                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
23975                 ndr->depth++;
23976                 ndr_print_ptr(ndr, "count", r->out.count);
23977                 ndr->depth++;
23978                 ndr_print_uint32(ndr, "count", *r->out.count);
23979                 ndr->depth--;
23980                 ndr_print_ptr(ndr, "info", r->out.info);
23981                 ndr->depth++;
23982                 ndr_print_ptr(ndr, "info", *r->out.info);
23983                 ndr->depth++;
23984                 if (*r->out.info) {
23985                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23986                         ndr->depth++;
23987                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23988                                 char *idx_2=NULL;
23989                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23990                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23991                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23992                                         free(idx_2);
23993                                 }
23994                         }
23995                         ndr->depth--;
23996                 }
23997                 ndr->depth--;
23998                 ndr->depth--;
23999                 ndr_print_ptr(ndr, "needed", r->out.needed);
24000                 ndr->depth++;
24001                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24002                 ndr->depth--;
24003                 ndr_print_WERROR(ndr, "result", r->out.result);
24004                 ndr->depth--;
24005         }
24006         ndr->depth--;
24007 }
24008
24009 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
24010 {
24011         if (flags & NDR_IN) {
24012                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
24013                 if (r->in.server_name) {
24014                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24015                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24016                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24017                         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));
24018                 }
24019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
24020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
24021                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
24023                 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));
24024         }
24025         if (flags & NDR_OUT) {
24026                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24027         }
24028         return NDR_ERR_SUCCESS;
24029 }
24030
24031 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
24032 {
24033         uint32_t _ptr_server_name;
24034         TALLOC_CTX *_mem_save_server_name_0;
24035         if (flags & NDR_IN) {
24036                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
24037                 if (_ptr_server_name) {
24038                         NDR_PULL_ALLOC(ndr, r->in.server_name);
24039                 } else {
24040                         r->in.server_name = NULL;
24041                 }
24042                 if (r->in.server_name) {
24043                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
24044                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
24045                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
24046                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
24047                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
24048                                 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));
24049                         }
24050                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
24051                         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));
24052                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
24053                 }
24054                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
24055                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
24056                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
24057                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
24058                         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));
24059                 }
24060                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
24061                 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));
24062         }
24063         if (flags & NDR_OUT) {
24064                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24065         }
24066         return NDR_ERR_SUCCESS;
24067 }
24068
24069 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
24070 {
24071         ndr_print_struct(ndr, name, "spoolss_AddPort");
24072         ndr->depth++;
24073         if (flags & NDR_SET_VALUES) {
24074                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24075         }
24076         if (flags & NDR_IN) {
24077                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
24078                 ndr->depth++;
24079                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
24080                 ndr->depth++;
24081                 if (r->in.server_name) {
24082                         ndr_print_string(ndr, "server_name", r->in.server_name);
24083                 }
24084                 ndr->depth--;
24085                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
24086                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
24087                 ndr->depth--;
24088         }
24089         if (flags & NDR_OUT) {
24090                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
24091                 ndr->depth++;
24092                 ndr_print_WERROR(ndr, "result", r->out.result);
24093                 ndr->depth--;
24094         }
24095         ndr->depth--;
24096 }
24097
24098 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
24099 {
24100         if (flags & NDR_IN) {
24101         }
24102         if (flags & NDR_OUT) {
24103                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24104         }
24105         return NDR_ERR_SUCCESS;
24106 }
24107
24108 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
24109 {
24110         if (flags & NDR_IN) {
24111         }
24112         if (flags & NDR_OUT) {
24113                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24114         }
24115         return NDR_ERR_SUCCESS;
24116 }
24117
24118 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
24119 {
24120         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
24121         ndr->depth++;
24122         if (flags & NDR_SET_VALUES) {
24123                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24124         }
24125         if (flags & NDR_IN) {
24126                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
24127                 ndr->depth++;
24128                 ndr->depth--;
24129         }
24130         if (flags & NDR_OUT) {
24131                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
24132                 ndr->depth++;
24133                 ndr_print_WERROR(ndr, "result", r->out.result);
24134                 ndr->depth--;
24135         }
24136         ndr->depth--;
24137 }
24138
24139 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
24140 {
24141         if (flags & NDR_IN) {
24142         }
24143         if (flags & NDR_OUT) {
24144                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24145         }
24146         return NDR_ERR_SUCCESS;
24147 }
24148
24149 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
24150 {
24151         if (flags & NDR_IN) {
24152         }
24153         if (flags & NDR_OUT) {
24154                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24155         }
24156         return NDR_ERR_SUCCESS;
24157 }
24158
24159 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
24160 {
24161         ndr_print_struct(ndr, name, "spoolss_DeletePort");
24162         ndr->depth++;
24163         if (flags & NDR_SET_VALUES) {
24164                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24165         }
24166         if (flags & NDR_IN) {
24167                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
24168                 ndr->depth++;
24169                 ndr->depth--;
24170         }
24171         if (flags & NDR_OUT) {
24172                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
24173                 ndr->depth++;
24174                 ndr_print_WERROR(ndr, "result", r->out.result);
24175                 ndr->depth--;
24176         }
24177         ndr->depth--;
24178 }
24179
24180 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
24181 {
24182         if (flags & NDR_IN) {
24183                 if (r->in.handle == NULL) {
24184                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24185                 }
24186                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24187                 if (r->in.devmode_ctr == NULL) {
24188                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24189                 }
24190                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24191         }
24192         if (flags & NDR_OUT) {
24193                 if (r->out.gdi_handle == NULL) {
24194                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24195                 }
24196                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24197                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24198         }
24199         return NDR_ERR_SUCCESS;
24200 }
24201
24202 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
24203 {
24204         TALLOC_CTX *_mem_save_handle_0;
24205         TALLOC_CTX *_mem_save_gdi_handle_0;
24206         TALLOC_CTX *_mem_save_devmode_ctr_0;
24207         if (flags & NDR_IN) {
24208                 ZERO_STRUCT(r->out);
24209
24210                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24211                         NDR_PULL_ALLOC(ndr, r->in.handle);
24212                 }
24213                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24214                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24215                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24216                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24217                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24218                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
24219                 }
24220                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
24221                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
24222                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24223                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
24224                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24225                 ZERO_STRUCTP(r->out.gdi_handle);
24226         }
24227         if (flags & NDR_OUT) {
24228                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24229                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24230                 }
24231                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24232                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
24233                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24234                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
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_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
24241 {
24242         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
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_CreatePrinterIC");
24249                 ndr->depth++;
24250                 ndr_print_ptr(ndr, "handle", r->in.handle);
24251                 ndr->depth++;
24252                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24253                 ndr->depth--;
24254                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
24255                 ndr->depth++;
24256                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
24257                 ndr->depth--;
24258                 ndr->depth--;
24259         }
24260         if (flags & NDR_OUT) {
24261                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
24262                 ndr->depth++;
24263                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
24264                 ndr->depth++;
24265                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
24266                 ndr->depth--;
24267                 ndr_print_WERROR(ndr, "result", r->out.result);
24268                 ndr->depth--;
24269         }
24270         ndr->depth--;
24271 }
24272
24273 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
24274 {
24275         if (flags & NDR_IN) {
24276         }
24277         if (flags & NDR_OUT) {
24278                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24279         }
24280         return NDR_ERR_SUCCESS;
24281 }
24282
24283 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
24284 {
24285         if (flags & NDR_IN) {
24286         }
24287         if (flags & NDR_OUT) {
24288                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24289         }
24290         return NDR_ERR_SUCCESS;
24291 }
24292
24293 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
24294 {
24295         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
24296         ndr->depth++;
24297         if (flags & NDR_SET_VALUES) {
24298                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24299         }
24300         if (flags & NDR_IN) {
24301                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
24302                 ndr->depth++;
24303                 ndr->depth--;
24304         }
24305         if (flags & NDR_OUT) {
24306                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
24307                 ndr->depth++;
24308                 ndr_print_WERROR(ndr, "result", r->out.result);
24309                 ndr->depth--;
24310         }
24311         ndr->depth--;
24312 }
24313
24314 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
24315 {
24316         if (flags & NDR_IN) {
24317                 if (r->in.gdi_handle == NULL) {
24318                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24319                 }
24320                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
24321         }
24322         if (flags & NDR_OUT) {
24323                 if (r->out.gdi_handle == NULL) {
24324                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24325                 }
24326                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24327                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24328         }
24329         return NDR_ERR_SUCCESS;
24330 }
24331
24332 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
24333 {
24334         TALLOC_CTX *_mem_save_gdi_handle_0;
24335         if (flags & NDR_IN) {
24336                 ZERO_STRUCT(r->out);
24337
24338                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24339                         NDR_PULL_ALLOC(ndr, r->in.gdi_handle);
24340                 }
24341                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24342                 NDR_PULL_SET_MEM_CTX(ndr, r->in.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
24343                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
24344                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
24345                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24346                 *r->out.gdi_handle = *r->in.gdi_handle;
24347         }
24348         if (flags & NDR_OUT) {
24349                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24350                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24351                 }
24352                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24353                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
24354                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24355                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
24356                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24357         }
24358         return NDR_ERR_SUCCESS;
24359 }
24360
24361 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
24362 {
24363         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
24364         ndr->depth++;
24365         if (flags & NDR_SET_VALUES) {
24366                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24367         }
24368         if (flags & NDR_IN) {
24369                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
24370                 ndr->depth++;
24371                 ndr_print_ptr(ndr, "gdi_handle", r->in.gdi_handle);
24372                 ndr->depth++;
24373                 ndr_print_policy_handle(ndr, "gdi_handle", r->in.gdi_handle);
24374                 ndr->depth--;
24375                 ndr->depth--;
24376         }
24377         if (flags & NDR_OUT) {
24378                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
24379                 ndr->depth++;
24380                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
24381                 ndr->depth++;
24382                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
24383                 ndr->depth--;
24384                 ndr_print_WERROR(ndr, "result", r->out.result);
24385                 ndr->depth--;
24386         }
24387         ndr->depth--;
24388 }
24389
24390 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
24391 {
24392         if (flags & NDR_IN) {
24393         }
24394         if (flags & NDR_OUT) {
24395                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24396         }
24397         return NDR_ERR_SUCCESS;
24398 }
24399
24400 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
24401 {
24402         if (flags & NDR_IN) {
24403         }
24404         if (flags & NDR_OUT) {
24405                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24406         }
24407         return NDR_ERR_SUCCESS;
24408 }
24409
24410 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
24411 {
24412         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
24413         ndr->depth++;
24414         if (flags & NDR_SET_VALUES) {
24415                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24416         }
24417         if (flags & NDR_IN) {
24418                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
24419                 ndr->depth++;
24420                 ndr->depth--;
24421         }
24422         if (flags & NDR_OUT) {
24423                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
24424                 ndr->depth++;
24425                 ndr_print_WERROR(ndr, "result", r->out.result);
24426                 ndr->depth--;
24427         }
24428         ndr->depth--;
24429 }
24430
24431 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
24432 {
24433         if (flags & NDR_IN) {
24434         }
24435         if (flags & NDR_OUT) {
24436                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24437         }
24438         return NDR_ERR_SUCCESS;
24439 }
24440
24441 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
24442 {
24443         if (flags & NDR_IN) {
24444         }
24445         if (flags & NDR_OUT) {
24446                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24447         }
24448         return NDR_ERR_SUCCESS;
24449 }
24450
24451 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
24452 {
24453         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
24454         ndr->depth++;
24455         if (flags & NDR_SET_VALUES) {
24456                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24457         }
24458         if (flags & NDR_IN) {
24459                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
24460                 ndr->depth++;
24461                 ndr->depth--;
24462         }
24463         if (flags & NDR_OUT) {
24464                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
24465                 ndr->depth++;
24466                 ndr_print_WERROR(ndr, "result", r->out.result);
24467                 ndr->depth--;
24468         }
24469         ndr->depth--;
24470 }
24471
24472 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
24473 {
24474         if (flags & NDR_IN) {
24475         }
24476         if (flags & NDR_OUT) {
24477                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24478         }
24479         return NDR_ERR_SUCCESS;
24480 }
24481
24482 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
24483 {
24484         if (flags & NDR_IN) {
24485         }
24486         if (flags & NDR_OUT) {
24487                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24488         }
24489         return NDR_ERR_SUCCESS;
24490 }
24491
24492 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
24493 {
24494         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
24495         ndr->depth++;
24496         if (flags & NDR_SET_VALUES) {
24497                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24498         }
24499         if (flags & NDR_IN) {
24500                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
24501                 ndr->depth++;
24502                 ndr->depth--;
24503         }
24504         if (flags & NDR_OUT) {
24505                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
24506                 ndr->depth++;
24507                 ndr_print_WERROR(ndr, "result", r->out.result);
24508                 ndr->depth--;
24509         }
24510         ndr->depth--;
24511 }
24512
24513 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
24514 {
24515         if (flags & NDR_IN) {
24516         }
24517         if (flags & NDR_OUT) {
24518                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24519         }
24520         return NDR_ERR_SUCCESS;
24521 }
24522
24523 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
24524 {
24525         if (flags & NDR_IN) {
24526         }
24527         if (flags & NDR_OUT) {
24528                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24529         }
24530         return NDR_ERR_SUCCESS;
24531 }
24532
24533 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
24534 {
24535         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
24536         ndr->depth++;
24537         if (flags & NDR_SET_VALUES) {
24538                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24539         }
24540         if (flags & NDR_IN) {
24541                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
24542                 ndr->depth++;
24543                 ndr->depth--;
24544         }
24545         if (flags & NDR_OUT) {
24546                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
24547                 ndr->depth++;
24548                 ndr_print_WERROR(ndr, "result", r->out.result);
24549                 ndr->depth--;
24550         }
24551         ndr->depth--;
24552 }
24553
24554 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
24555 {
24556         if (flags & NDR_IN) {
24557         }
24558         if (flags & NDR_OUT) {
24559                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24560         }
24561         return NDR_ERR_SUCCESS;
24562 }
24563
24564 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
24565 {
24566         if (flags & NDR_IN) {
24567         }
24568         if (flags & NDR_OUT) {
24569                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24570         }
24571         return NDR_ERR_SUCCESS;
24572 }
24573
24574 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
24575 {
24576         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
24577         ndr->depth++;
24578         if (flags & NDR_SET_VALUES) {
24579                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24580         }
24581         if (flags & NDR_IN) {
24582                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
24583                 ndr->depth++;
24584                 ndr->depth--;
24585         }
24586         if (flags & NDR_OUT) {
24587                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
24588                 ndr->depth++;
24589                 ndr_print_WERROR(ndr, "result", r->out.result);
24590                 ndr->depth--;
24591         }
24592         ndr->depth--;
24593 }
24594
24595 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
24596 {
24597         if (flags & NDR_IN) {
24598         }
24599         if (flags & NDR_OUT) {
24600                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24601         }
24602         return NDR_ERR_SUCCESS;
24603 }
24604
24605 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
24606 {
24607         if (flags & NDR_IN) {
24608         }
24609         if (flags & NDR_OUT) {
24610                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24611         }
24612         return NDR_ERR_SUCCESS;
24613 }
24614
24615 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
24616 {
24617         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
24618         ndr->depth++;
24619         if (flags & NDR_SET_VALUES) {
24620                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24621         }
24622         if (flags & NDR_IN) {
24623                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
24624                 ndr->depth++;
24625                 ndr->depth--;
24626         }
24627         if (flags & NDR_OUT) {
24628                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
24629                 ndr->depth++;
24630                 ndr_print_WERROR(ndr, "result", r->out.result);
24631                 ndr->depth--;
24632         }
24633         ndr->depth--;
24634 }
24635
24636 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
24637 {
24638         if (flags & NDR_IN) {
24639         }
24640         if (flags & NDR_OUT) {
24641                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24642         }
24643         return NDR_ERR_SUCCESS;
24644 }
24645
24646 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
24647 {
24648         if (flags & NDR_IN) {
24649         }
24650         if (flags & NDR_OUT) {
24651                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24652         }
24653         return NDR_ERR_SUCCESS;
24654 }
24655
24656 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
24657 {
24658         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
24659         ndr->depth++;
24660         if (flags & NDR_SET_VALUES) {
24661                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24662         }
24663         if (flags & NDR_IN) {
24664                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
24665                 ndr->depth++;
24666                 ndr->depth--;
24667         }
24668         if (flags & NDR_OUT) {
24669                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
24670                 ndr->depth++;
24671                 ndr_print_WERROR(ndr, "result", r->out.result);
24672                 ndr->depth--;
24673         }
24674         ndr->depth--;
24675 }
24676
24677 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
24678 {
24679         if (flags & NDR_IN) {
24680         }
24681         if (flags & NDR_OUT) {
24682                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24683         }
24684         return NDR_ERR_SUCCESS;
24685 }
24686
24687 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
24688 {
24689         if (flags & NDR_IN) {
24690         }
24691         if (flags & NDR_OUT) {
24692                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24693         }
24694         return NDR_ERR_SUCCESS;
24695 }
24696
24697 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
24698 {
24699         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
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_DeletePrintProvidor");
24706                 ndr->depth++;
24707                 ndr->depth--;
24708         }
24709         if (flags & NDR_OUT) {
24710                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
24711                 ndr->depth++;
24712                 ndr_print_WERROR(ndr, "result", r->out.result);
24713                 ndr->depth--;
24714         }
24715         ndr->depth--;
24716 }
24717
24718 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
24719 {
24720         if (flags & NDR_IN) {
24721                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24722                 if (r->in.servername) {
24723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24725                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24726                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24727                 }
24728                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
24729                 if (r->in.print_processor_name) {
24730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
24731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
24733                         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));
24734                 }
24735                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24736                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24737                 if (r->in.buffer) {
24738                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24739                 }
24740                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24741         }
24742         if (flags & NDR_OUT) {
24743                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24744                 if (r->out.info) {
24745                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24746                 }
24747                 if (r->out.needed == NULL) {
24748                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24749                 }
24750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24751                 if (r->out.count == NULL) {
24752                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24753                 }
24754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24755                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24756         }
24757         return NDR_ERR_SUCCESS;
24758 }
24759
24760 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
24761 {
24762         uint32_t _ptr_servername;
24763         uint32_t _ptr_print_processor_name;
24764         uint32_t _ptr_buffer;
24765         uint32_t _ptr_info;
24766         TALLOC_CTX *_mem_save_servername_0;
24767         TALLOC_CTX *_mem_save_print_processor_name_0;
24768         TALLOC_CTX *_mem_save_buffer_0;
24769         TALLOC_CTX *_mem_save_info_0;
24770         TALLOC_CTX *_mem_save_needed_0;
24771         TALLOC_CTX *_mem_save_count_0;
24772         if (flags & NDR_IN) {
24773                 ZERO_STRUCT(r->out);
24774
24775                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24776                 if (_ptr_servername) {
24777                         NDR_PULL_ALLOC(ndr, r->in.servername);
24778                 } else {
24779                         r->in.servername = NULL;
24780                 }
24781                 if (r->in.servername) {
24782                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24783                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24784                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24785                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24786                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24787                                 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));
24788                         }
24789                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24790                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24791                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24792                 }
24793                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
24794                 if (_ptr_print_processor_name) {
24795                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
24796                 } else {
24797                         r->in.print_processor_name = NULL;
24798                 }
24799                 if (r->in.print_processor_name) {
24800                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
24801                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
24802                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
24803                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
24804                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
24805                                 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));
24806                         }
24807                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
24808                         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));
24809                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
24810                 }
24811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24812                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24813                 if (_ptr_buffer) {
24814                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24815                 } else {
24816                         r->in.buffer = NULL;
24817                 }
24818                 if (r->in.buffer) {
24819                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24820                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24821                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24822                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24823                 }
24824                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24825                 NDR_PULL_ALLOC(ndr, r->out.needed);
24826                 ZERO_STRUCTP(r->out.needed);
24827                 NDR_PULL_ALLOC(ndr, r->out.count);
24828                 ZERO_STRUCTP(r->out.count);
24829         }
24830         if (flags & NDR_OUT) {
24831                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24832                 if (_ptr_info) {
24833                         NDR_PULL_ALLOC(ndr, r->out.info);
24834                 } else {
24835                         r->out.info = NULL;
24836                 }
24837                 if (r->out.info) {
24838                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24839                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24840                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24841                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24842                 }
24843                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24844                         NDR_PULL_ALLOC(ndr, r->out.needed);
24845                 }
24846                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24847                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24849                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24850                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24851                         NDR_PULL_ALLOC(ndr, r->out.count);
24852                 }
24853                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24854                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24856                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24857                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24858         }
24859         return NDR_ERR_SUCCESS;
24860 }
24861
24862 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
24863 {
24864         uint32_t cntr_info_0;
24865         if (flags & NDR_IN) {
24866                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24867                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24868         }
24869         if (flags & NDR_OUT) {
24870                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24871                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24872                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24873                 }
24874                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24875                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24876                 }
24877         }
24878         return NDR_ERR_SUCCESS;
24879 }
24880
24881 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
24882 {
24883         uint32_t cntr_info_0;
24884         TALLOC_CTX *_mem_save_info_0;
24885         if (flags & NDR_IN) {
24886                 ZERO_STRUCT(r->out);
24887
24888                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24889                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24890         }
24891         if (flags & NDR_OUT) {
24892                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24893                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24894                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24895                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24896                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24897                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24898                 }
24899                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24900                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24901                 }
24902                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24903         }
24904         return NDR_ERR_SUCCESS;
24905 }
24906
24907 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
24908 {
24909         uint32_t cntr_info_2;
24910         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
24911         ndr->depth++;
24912         if (flags & NDR_SET_VALUES) {
24913                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24914         }
24915         if (flags & NDR_IN) {
24916                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
24917                 ndr->depth++;
24918                 ndr_print_ptr(ndr, "servername", r->in.servername);
24919                 ndr->depth++;
24920                 if (r->in.servername) {
24921                         ndr_print_string(ndr, "servername", r->in.servername);
24922                 }
24923                 ndr->depth--;
24924                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
24925                 ndr->depth++;
24926                 if (r->in.print_processor_name) {
24927                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
24928                 }
24929                 ndr->depth--;
24930                 ndr_print_uint32(ndr, "level", r->in.level);
24931                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24932                 ndr->depth++;
24933                 if (r->in.buffer) {
24934                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24935                 }
24936                 ndr->depth--;
24937                 ndr_print_uint32(ndr, "offered", r->in.offered);
24938                 ndr->depth--;
24939         }
24940         if (flags & NDR_OUT) {
24941                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
24942                 ndr->depth++;
24943                 ndr_print_ptr(ndr, "count", r->out.count);
24944                 ndr->depth++;
24945                 ndr_print_uint32(ndr, "count", *r->out.count);
24946                 ndr->depth--;
24947                 ndr_print_ptr(ndr, "info", r->out.info);
24948                 ndr->depth++;
24949                 ndr_print_ptr(ndr, "info", *r->out.info);
24950                 ndr->depth++;
24951                 if (*r->out.info) {
24952                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24953                         ndr->depth++;
24954                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24955                                 char *idx_2=NULL;
24956                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24957                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24958                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24959                                         free(idx_2);
24960                                 }
24961                         }
24962                         ndr->depth--;
24963                 }
24964                 ndr->depth--;
24965                 ndr->depth--;
24966                 ndr_print_ptr(ndr, "needed", r->out.needed);
24967                 ndr->depth++;
24968                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24969                 ndr->depth--;
24970                 ndr_print_WERROR(ndr, "result", r->out.result);
24971                 ndr->depth--;
24972         }
24973         ndr->depth--;
24974 }
24975
24976 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
24977 {
24978         if (flags & NDR_IN) {
24979                 if (r->in.handle == NULL) {
24980                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24981                 }
24982                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24983                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
24984                 if (r->in.data_type) {
24985                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
24986                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24987                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
24988                         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));
24989                 }
24990                 if (r->in.devmode_ctr == NULL) {
24991                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24992                 }
24993                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24994         }
24995         if (flags & NDR_OUT) {
24996                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24997         }
24998         return NDR_ERR_SUCCESS;
24999 }
25000
25001 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
25002 {
25003         uint32_t _ptr_data_type;
25004         TALLOC_CTX *_mem_save_handle_0;
25005         TALLOC_CTX *_mem_save_data_type_0;
25006         TALLOC_CTX *_mem_save_devmode_ctr_0;
25007         if (flags & NDR_IN) {
25008                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25009                         NDR_PULL_ALLOC(ndr, r->in.handle);
25010                 }
25011                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25012                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25013                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25014                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25015                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
25016                 if (_ptr_data_type) {
25017                         NDR_PULL_ALLOC(ndr, r->in.data_type);
25018                 } else {
25019                         r->in.data_type = NULL;
25020                 }
25021                 if (r->in.data_type) {
25022                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25023                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
25024                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
25025                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
25026                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
25027                                 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));
25028                         }
25029                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
25030                         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));
25031                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
25032                 }
25033                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25034                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25035                 }
25036                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25037                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25038                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25039                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25040         }
25041         if (flags & NDR_OUT) {
25042                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25043         }
25044         return NDR_ERR_SUCCESS;
25045 }
25046
25047 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
25048 {
25049         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
25050         ndr->depth++;
25051         if (flags & NDR_SET_VALUES) {
25052                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25053         }
25054         if (flags & NDR_IN) {
25055                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
25056                 ndr->depth++;
25057                 ndr_print_ptr(ndr, "handle", r->in.handle);
25058                 ndr->depth++;
25059                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25060                 ndr->depth--;
25061                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
25062                 ndr->depth++;
25063                 if (r->in.data_type) {
25064                         ndr_print_string(ndr, "data_type", r->in.data_type);
25065                 }
25066                 ndr->depth--;
25067                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25068                 ndr->depth++;
25069                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25070                 ndr->depth--;
25071                 ndr->depth--;
25072         }
25073         if (flags & NDR_OUT) {
25074                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
25075                 ndr->depth++;
25076                 ndr_print_WERROR(ndr, "result", r->out.result);
25077                 ndr->depth--;
25078         }
25079         ndr->depth--;
25080 }
25081
25082 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
25083 {
25084         if (flags & NDR_IN) {
25085                 if (r->in.handle == NULL) {
25086                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25087                 }
25088                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25089                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
25090                 if (r->in.architecture) {
25091                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
25092                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25093                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
25094                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25095                 }
25096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25097                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25098                 if (r->in.buffer) {
25099                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25100                 }
25101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
25103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
25104         }
25105         if (flags & NDR_OUT) {
25106                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25107                 if (r->out.info) {
25108                         {
25109                                 struct ndr_push *_ndr_info;
25110                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
25111                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
25112                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
25113                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
25114                         }
25115                 }
25116                 if (r->out.needed == NULL) {
25117                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25118                 }
25119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25120                 if (r->out.server_major_version == NULL) {
25121                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25122                 }
25123                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
25124                 if (r->out.server_minor_version == NULL) {
25125                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25126                 }
25127                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
25128                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25129         }
25130         return NDR_ERR_SUCCESS;
25131 }
25132
25133 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
25134 {
25135         uint32_t _ptr_architecture;
25136         uint32_t _ptr_buffer;
25137         uint32_t _ptr_info;
25138         TALLOC_CTX *_mem_save_handle_0;
25139         TALLOC_CTX *_mem_save_architecture_0;
25140         TALLOC_CTX *_mem_save_buffer_0;
25141         TALLOC_CTX *_mem_save_info_0;
25142         TALLOC_CTX *_mem_save_needed_0;
25143         TALLOC_CTX *_mem_save_server_major_version_0;
25144         TALLOC_CTX *_mem_save_server_minor_version_0;
25145         if (flags & NDR_IN) {
25146                 ZERO_STRUCT(r->out);
25147
25148                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25149                         NDR_PULL_ALLOC(ndr, r->in.handle);
25150                 }
25151                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25152                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25153                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25154                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25155                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
25156                 if (_ptr_architecture) {
25157                         NDR_PULL_ALLOC(ndr, r->in.architecture);
25158                 } else {
25159                         r->in.architecture = NULL;
25160                 }
25161                 if (r->in.architecture) {
25162                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
25163                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
25164                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
25165                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
25166                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
25167                                 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));
25168                         }
25169                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
25170                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
25171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
25172                 }
25173                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25174                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25175                 if (_ptr_buffer) {
25176                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25177                 } else {
25178                         r->in.buffer = NULL;
25179                 }
25180                 if (r->in.buffer) {
25181                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25182                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25183                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25184                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25185                 }
25186                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25187                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
25188                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
25189                 NDR_PULL_ALLOC(ndr, r->out.needed);
25190                 ZERO_STRUCTP(r->out.needed);
25191                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
25192                 ZERO_STRUCTP(r->out.server_major_version);
25193                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
25194                 ZERO_STRUCTP(r->out.server_minor_version);
25195         }
25196         if (flags & NDR_OUT) {
25197                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25198                 if (_ptr_info) {
25199                         NDR_PULL_ALLOC(ndr, r->out.info);
25200                 } else {
25201                         r->out.info = NULL;
25202                 }
25203                 if (r->out.info) {
25204                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25205                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25206                         {
25207                                 struct ndr_pull *_ndr_info;
25208                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
25209                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
25210                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
25211                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
25212                         }
25213                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25214                 }
25215                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25216                         NDR_PULL_ALLOC(ndr, r->out.needed);
25217                 }
25218                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25219                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25221                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25222                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25223                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
25224                 }
25225                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
25226                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
25227                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
25228                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
25229                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25230                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
25231                 }
25232                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
25233                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
25234                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
25235                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
25236                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25237         }
25238         return NDR_ERR_SUCCESS;
25239 }
25240
25241 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
25242 {
25243         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
25244         ndr->depth++;
25245         if (flags & NDR_SET_VALUES) {
25246                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25247         }
25248         if (flags & NDR_IN) {
25249                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
25250                 ndr->depth++;
25251                 ndr_print_ptr(ndr, "handle", r->in.handle);
25252                 ndr->depth++;
25253                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25254                 ndr->depth--;
25255                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
25256                 ndr->depth++;
25257                 if (r->in.architecture) {
25258                         ndr_print_string(ndr, "architecture", r->in.architecture);
25259                 }
25260                 ndr->depth--;
25261                 ndr_print_uint32(ndr, "level", r->in.level);
25262                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25263                 ndr->depth++;
25264                 if (r->in.buffer) {
25265                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25266                 }
25267                 ndr->depth--;
25268                 ndr_print_uint32(ndr, "offered", r->in.offered);
25269                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
25270                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
25271                 ndr->depth--;
25272         }
25273         if (flags & NDR_OUT) {
25274                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
25275                 ndr->depth++;
25276                 ndr_print_ptr(ndr, "info", r->out.info);
25277                 ndr->depth++;
25278                 if (r->out.info) {
25279                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
25280                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
25281                 }
25282                 ndr->depth--;
25283                 ndr_print_ptr(ndr, "needed", r->out.needed);
25284                 ndr->depth++;
25285                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25286                 ndr->depth--;
25287                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
25288                 ndr->depth++;
25289                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
25290                 ndr->depth--;
25291                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
25292                 ndr->depth++;
25293                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
25294                 ndr->depth--;
25295                 ndr_print_WERROR(ndr, "result", r->out.result);
25296                 ndr->depth--;
25297         }
25298         ndr->depth--;
25299 }
25300
25301 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
25302 {
25303         if (flags & NDR_IN) {
25304         }
25305         if (flags & NDR_OUT) {
25306                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25307         }
25308         return NDR_ERR_SUCCESS;
25309 }
25310
25311 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
25312 {
25313         if (flags & NDR_IN) {
25314         }
25315         if (flags & NDR_OUT) {
25316                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25317         }
25318         return NDR_ERR_SUCCESS;
25319 }
25320
25321 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
25322 {
25323         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
25324         ndr->depth++;
25325         if (flags & NDR_SET_VALUES) {
25326                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25327         }
25328         if (flags & NDR_IN) {
25329                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
25330                 ndr->depth++;
25331                 ndr->depth--;
25332         }
25333         if (flags & NDR_OUT) {
25334                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
25335                 ndr->depth++;
25336                 ndr_print_WERROR(ndr, "result", r->out.result);
25337                 ndr->depth--;
25338         }
25339         ndr->depth--;
25340 }
25341
25342 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
25343 {
25344         if (flags & NDR_IN) {
25345         }
25346         if (flags & NDR_OUT) {
25347                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25348         }
25349         return NDR_ERR_SUCCESS;
25350 }
25351
25352 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
25353 {
25354         if (flags & NDR_IN) {
25355         }
25356         if (flags & NDR_OUT) {
25357                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25358         }
25359         return NDR_ERR_SUCCESS;
25360 }
25361
25362 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
25363 {
25364         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
25365         ndr->depth++;
25366         if (flags & NDR_SET_VALUES) {
25367                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25368         }
25369         if (flags & NDR_IN) {
25370                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
25371                 ndr->depth++;
25372                 ndr->depth--;
25373         }
25374         if (flags & NDR_OUT) {
25375                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
25376                 ndr->depth++;
25377                 ndr_print_WERROR(ndr, "result", r->out.result);
25378                 ndr->depth--;
25379         }
25380         ndr->depth--;
25381 }
25382
25383 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
25384 {
25385         if (flags & NDR_IN) {
25386                 if (r->in.handle == NULL) {
25387                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25388                 }
25389                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25390         }
25391         if (flags & NDR_OUT) {
25392                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25393         }
25394         return NDR_ERR_SUCCESS;
25395 }
25396
25397 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
25398 {
25399         TALLOC_CTX *_mem_save_handle_0;
25400         if (flags & NDR_IN) {
25401                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25402                         NDR_PULL_ALLOC(ndr, r->in.handle);
25403                 }
25404                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25405                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25406                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25407                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25408         }
25409         if (flags & NDR_OUT) {
25410                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25411         }
25412         return NDR_ERR_SUCCESS;
25413 }
25414
25415 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
25416 {
25417         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
25418         ndr->depth++;
25419         if (flags & NDR_SET_VALUES) {
25420                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25421         }
25422         if (flags & NDR_IN) {
25423                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
25424                 ndr->depth++;
25425                 ndr_print_ptr(ndr, "handle", r->in.handle);
25426                 ndr->depth++;
25427                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25428                 ndr->depth--;
25429                 ndr->depth--;
25430         }
25431         if (flags & NDR_OUT) {
25432                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
25433                 ndr->depth++;
25434                 ndr_print_WERROR(ndr, "result", r->out.result);
25435                 ndr->depth--;
25436         }
25437         ndr->depth--;
25438 }
25439
25440 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
25441 {
25442         if (flags & NDR_IN) {
25443         }
25444         if (flags & NDR_OUT) {
25445                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25446         }
25447         return NDR_ERR_SUCCESS;
25448 }
25449
25450 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
25451 {
25452         if (flags & NDR_IN) {
25453         }
25454         if (flags & NDR_OUT) {
25455                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25456         }
25457         return NDR_ERR_SUCCESS;
25458 }
25459
25460 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
25461 {
25462         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
25463         ndr->depth++;
25464         if (flags & NDR_SET_VALUES) {
25465                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25466         }
25467         if (flags & NDR_IN) {
25468                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
25469                 ndr->depth++;
25470                 ndr->depth--;
25471         }
25472         if (flags & NDR_OUT) {
25473                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
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_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
25482 {
25483         if (flags & NDR_IN) {
25484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
25485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25486                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
25487                 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));
25488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
25489                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
25490                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
25491                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25492                 if (r->in.buffer) {
25493                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
25494                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
25495                 }
25496         }
25497         if (flags & NDR_OUT) {
25498                 if (r->out.handle == NULL) {
25499                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25500                 }
25501                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25502                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25503         }
25504         return NDR_ERR_SUCCESS;
25505 }
25506
25507 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
25508 {
25509         uint32_t _ptr_buffer;
25510         TALLOC_CTX *_mem_save_buffer_0;
25511         TALLOC_CTX *_mem_save_handle_0;
25512         if (flags & NDR_IN) {
25513                 ZERO_STRUCT(r->out);
25514
25515                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
25516                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
25517                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
25518                         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));
25519                 }
25520                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
25521                 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));
25522                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
25523                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
25524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
25525                 if (r->in.bufsize > 512) {
25526                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
25527                 }
25528                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25529                 if (_ptr_buffer) {
25530                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25531                 } else {
25532                         r->in.buffer = NULL;
25533                 }
25534                 if (r->in.buffer) {
25535                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25536                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25537                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
25538                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
25539                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
25540                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25541                 }
25542                 NDR_PULL_ALLOC(ndr, r->out.handle);
25543                 ZERO_STRUCTP(r->out.handle);
25544                 if (r->in.buffer) {
25545                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
25546                 }
25547         }
25548         if (flags & NDR_OUT) {
25549                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25550                         NDR_PULL_ALLOC(ndr, r->out.handle);
25551                 }
25552                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25553                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25554                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25555                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25556                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25557         }
25558         return NDR_ERR_SUCCESS;
25559 }
25560
25561 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
25562 {
25563         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
25564         ndr->depth++;
25565         if (flags & NDR_SET_VALUES) {
25566                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25567         }
25568         if (flags & NDR_IN) {
25569                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
25570                 ndr->depth++;
25571                 ndr_print_string(ndr, "server_name", r->in.server_name);
25572                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
25573                 ndr_print_winreg_Type(ndr, "type", r->in.type);
25574                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
25575                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25576                 ndr->depth++;
25577                 if (r->in.buffer) {
25578                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
25579                 }
25580                 ndr->depth--;
25581                 ndr->depth--;
25582         }
25583         if (flags & NDR_OUT) {
25584                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
25585                 ndr->depth++;
25586                 ndr_print_ptr(ndr, "handle", r->out.handle);
25587                 ndr->depth++;
25588                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25589                 ndr->depth--;
25590                 ndr_print_WERROR(ndr, "result", r->out.result);
25591                 ndr->depth--;
25592         }
25593         ndr->depth--;
25594 }
25595
25596 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
25597 {
25598         if (flags & NDR_IN) {
25599                 if (r->in.handle == NULL) {
25600                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25601                 }
25602                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25603                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
25604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
25605                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25606                 if (r->in.buffer) {
25607                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
25608                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
25609                 }
25610         }
25611         if (flags & NDR_OUT) {
25612                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25613         }
25614         return NDR_ERR_SUCCESS;
25615 }
25616
25617 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
25618 {
25619         uint32_t _ptr_buffer;
25620         TALLOC_CTX *_mem_save_handle_0;
25621         TALLOC_CTX *_mem_save_buffer_0;
25622         if (flags & NDR_IN) {
25623                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25624                         NDR_PULL_ALLOC(ndr, r->in.handle);
25625                 }
25626                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25627                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25628                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25629                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25630                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
25631                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
25632                 if (r->in.bufsize > 512) {
25633                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
25634                 }
25635                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25636                 if (_ptr_buffer) {
25637                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25638                 } else {
25639                         r->in.buffer = NULL;
25640                 }
25641                 if (r->in.buffer) {
25642                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25643                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25644                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
25645                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
25646                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
25647                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25648                 }
25649                 if (r->in.buffer) {
25650                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
25651                 }
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_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
25660 {
25661         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
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_RouterReplyPrinter");
25668                 ndr->depth++;
25669                 ndr_print_ptr(ndr, "handle", r->in.handle);
25670                 ndr->depth++;
25671                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25672                 ndr->depth--;
25673                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
25674                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
25675                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25676                 ndr->depth++;
25677                 if (r->in.buffer) {
25678                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
25679                 }
25680                 ndr->depth--;
25681                 ndr->depth--;
25682         }
25683         if (flags & NDR_OUT) {
25684                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
25685                 ndr->depth++;
25686                 ndr_print_WERROR(ndr, "result", r->out.result);
25687                 ndr->depth--;
25688         }
25689         ndr->depth--;
25690 }
25691
25692 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
25693 {
25694         if (flags & NDR_IN) {
25695                 if (r->in.handle == NULL) {
25696                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25697                 }
25698                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25699         }
25700         if (flags & NDR_OUT) {
25701                 if (r->out.handle == NULL) {
25702                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25703                 }
25704                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25705                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25706         }
25707         return NDR_ERR_SUCCESS;
25708 }
25709
25710 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
25711 {
25712         TALLOC_CTX *_mem_save_handle_0;
25713         if (flags & NDR_IN) {
25714                 ZERO_STRUCT(r->out);
25715
25716                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25717                         NDR_PULL_ALLOC(ndr, r->in.handle);
25718                 }
25719                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25720                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25721                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25722                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25723                 NDR_PULL_ALLOC(ndr, r->out.handle);
25724                 *r->out.handle = *r->in.handle;
25725         }
25726         if (flags & NDR_OUT) {
25727                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25728                         NDR_PULL_ALLOC(ndr, r->out.handle);
25729                 }
25730                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25731                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25732                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25733                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25734                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25735         }
25736         return NDR_ERR_SUCCESS;
25737 }
25738
25739 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
25740 {
25741         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
25742         ndr->depth++;
25743         if (flags & NDR_SET_VALUES) {
25744                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25745         }
25746         if (flags & NDR_IN) {
25747                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
25748                 ndr->depth++;
25749                 ndr_print_ptr(ndr, "handle", r->in.handle);
25750                 ndr->depth++;
25751                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25752                 ndr->depth--;
25753                 ndr->depth--;
25754         }
25755         if (flags & NDR_OUT) {
25756                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
25757                 ndr->depth++;
25758                 ndr_print_ptr(ndr, "handle", r->out.handle);
25759                 ndr->depth++;
25760                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25761                 ndr->depth--;
25762                 ndr_print_WERROR(ndr, "result", r->out.result);
25763                 ndr->depth--;
25764         }
25765         ndr->depth--;
25766 }
25767
25768 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
25769 {
25770         if (flags & NDR_IN) {
25771         }
25772         if (flags & NDR_OUT) {
25773                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25774         }
25775         return NDR_ERR_SUCCESS;
25776 }
25777
25778 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
25779 {
25780         if (flags & NDR_IN) {
25781         }
25782         if (flags & NDR_OUT) {
25783                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25784         }
25785         return NDR_ERR_SUCCESS;
25786 }
25787
25788 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
25789 {
25790         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
25791         ndr->depth++;
25792         if (flags & NDR_SET_VALUES) {
25793                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25794         }
25795         if (flags & NDR_IN) {
25796                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
25797                 ndr->depth++;
25798                 ndr->depth--;
25799         }
25800         if (flags & NDR_OUT) {
25801                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
25802                 ndr->depth++;
25803                 ndr_print_WERROR(ndr, "result", r->out.result);
25804                 ndr->depth--;
25805         }
25806         ndr->depth--;
25807 }
25808
25809 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
25810 {
25811         if (flags & NDR_IN) {
25812         }
25813         if (flags & NDR_OUT) {
25814                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25815         }
25816         return NDR_ERR_SUCCESS;
25817 }
25818
25819 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
25820 {
25821         if (flags & NDR_IN) {
25822         }
25823         if (flags & NDR_OUT) {
25824                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25825         }
25826         return NDR_ERR_SUCCESS;
25827 }
25828
25829 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
25830 {
25831         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
25832         ndr->depth++;
25833         if (flags & NDR_SET_VALUES) {
25834                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25835         }
25836         if (flags & NDR_IN) {
25837                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
25838                 ndr->depth++;
25839                 ndr->depth--;
25840         }
25841         if (flags & NDR_OUT) {
25842                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
25843                 ndr->depth++;
25844                 ndr_print_WERROR(ndr, "result", r->out.result);
25845                 ndr->depth--;
25846         }
25847         ndr->depth--;
25848 }
25849
25850 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
25851 {
25852         if (flags & NDR_IN) {
25853         }
25854         if (flags & NDR_OUT) {
25855                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25856         }
25857         return NDR_ERR_SUCCESS;
25858 }
25859
25860 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
25861 {
25862         if (flags & NDR_IN) {
25863         }
25864         if (flags & NDR_OUT) {
25865                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25866         }
25867         return NDR_ERR_SUCCESS;
25868 }
25869
25870 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
25871 {
25872         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
25873         ndr->depth++;
25874         if (flags & NDR_SET_VALUES) {
25875                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25876         }
25877         if (flags & NDR_IN) {
25878                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
25879                 ndr->depth++;
25880                 ndr->depth--;
25881         }
25882         if (flags & NDR_OUT) {
25883                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
25884                 ndr->depth++;
25885                 ndr_print_WERROR(ndr, "result", r->out.result);
25886                 ndr->depth--;
25887         }
25888         ndr->depth--;
25889 }
25890
25891 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
25892 {
25893         if (flags & NDR_IN) {
25894         }
25895         if (flags & NDR_OUT) {
25896                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25897         }
25898         return NDR_ERR_SUCCESS;
25899 }
25900
25901 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
25902 {
25903         if (flags & NDR_IN) {
25904         }
25905         if (flags & NDR_OUT) {
25906                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25907         }
25908         return NDR_ERR_SUCCESS;
25909 }
25910
25911 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
25912 {
25913         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
25914         ndr->depth++;
25915         if (flags & NDR_SET_VALUES) {
25916                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25917         }
25918         if (flags & NDR_IN) {
25919                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
25920                 ndr->depth++;
25921                 ndr->depth--;
25922         }
25923         if (flags & NDR_OUT) {
25924                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
25925                 ndr->depth++;
25926                 ndr_print_WERROR(ndr, "result", r->out.result);
25927                 ndr->depth--;
25928         }
25929         ndr->depth--;
25930 }
25931
25932 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
25933 {
25934         if (flags & NDR_IN) {
25935                 if (r->in.handle == NULL) {
25936                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25937                 }
25938                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25939                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
25940                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
25941                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
25942                 if (r->in.local_machine) {
25943                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
25944                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25945                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
25946                         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));
25947                 }
25948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
25949                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
25950                 if (r->in.notify_options) {
25951                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
25952                 }
25953         }
25954         if (flags & NDR_OUT) {
25955                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25956         }
25957         return NDR_ERR_SUCCESS;
25958 }
25959
25960 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
25961 {
25962         uint32_t _ptr_local_machine;
25963         uint32_t _ptr_notify_options;
25964         TALLOC_CTX *_mem_save_handle_0;
25965         TALLOC_CTX *_mem_save_local_machine_0;
25966         TALLOC_CTX *_mem_save_notify_options_0;
25967         if (flags & NDR_IN) {
25968                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25969                         NDR_PULL_ALLOC(ndr, r->in.handle);
25970                 }
25971                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25972                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25973                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25974                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25975                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
25976                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
25977                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
25978                 if (_ptr_local_machine) {
25979                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
25980                 } else {
25981                         r->in.local_machine = NULL;
25982                 }
25983                 if (r->in.local_machine) {
25984                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
25985                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
25986                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
25987                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
25988                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
25989                                 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));
25990                         }
25991                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
25992                         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));
25993                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
25994                 }
25995                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
25996                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
25997                 if (_ptr_notify_options) {
25998                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
25999                 } else {
26000                         r->in.notify_options = NULL;
26001                 }
26002                 if (r->in.notify_options) {
26003                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
26004                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
26005                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
26006                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
26007                 }
26008         }
26009         if (flags & NDR_OUT) {
26010                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26011         }
26012         return NDR_ERR_SUCCESS;
26013 }
26014
26015 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26016 {
26017         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26018         ndr->depth++;
26019         if (flags & NDR_SET_VALUES) {
26020                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26021         }
26022         if (flags & NDR_IN) {
26023                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26024                 ndr->depth++;
26025                 ndr_print_ptr(ndr, "handle", r->in.handle);
26026                 ndr->depth++;
26027                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26028                 ndr->depth--;
26029                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26030                 ndr_print_uint32(ndr, "options", r->in.options);
26031                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
26032                 ndr->depth++;
26033                 if (r->in.local_machine) {
26034                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
26035                 }
26036                 ndr->depth--;
26037                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
26038                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
26039                 ndr->depth++;
26040                 if (r->in.notify_options) {
26041                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
26042                 }
26043                 ndr->depth--;
26044                 ndr->depth--;
26045         }
26046         if (flags & NDR_OUT) {
26047                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26048                 ndr->depth++;
26049                 ndr_print_WERROR(ndr, "result", r->out.result);
26050                 ndr->depth--;
26051         }
26052         ndr->depth--;
26053 }
26054
26055 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
26056 {
26057         if (flags & NDR_IN) {
26058                 if (r->in.handle == NULL) {
26059                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26060                 }
26061                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26062                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
26063                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
26065                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
26066                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
26067         }
26068         if (flags & NDR_OUT) {
26069                 if (r->out.reply_result == NULL) {
26070                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26071                 }
26072                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
26073                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26074         }
26075         return NDR_ERR_SUCCESS;
26076 }
26077
26078 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
26079 {
26080         TALLOC_CTX *_mem_save_handle_0;
26081         TALLOC_CTX *_mem_save_reply_result_0;
26082         if (flags & NDR_IN) {
26083                 ZERO_STRUCT(r->out);
26084
26085                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26086                         NDR_PULL_ALLOC(ndr, r->in.handle);
26087                 }
26088                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26089                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26090                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26091                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26092                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
26093                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
26095                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
26096                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
26097                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
26098                 ZERO_STRUCTP(r->out.reply_result);
26099         }
26100         if (flags & NDR_OUT) {
26101                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26102                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
26103                 }
26104                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
26105                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
26106                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
26107                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
26108                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26109         }
26110         return NDR_ERR_SUCCESS;
26111 }
26112
26113 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
26114 {
26115         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
26116         ndr->depth++;
26117         if (flags & NDR_SET_VALUES) {
26118                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26119         }
26120         if (flags & NDR_IN) {
26121                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
26122                 ndr->depth++;
26123                 ndr_print_ptr(ndr, "handle", r->in.handle);
26124                 ndr->depth++;
26125                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26126                 ndr->depth--;
26127                 ndr_print_uint32(ndr, "color", r->in.color);
26128                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26129                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
26130                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
26131                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
26132                 ndr->depth--;
26133         }
26134         if (flags & NDR_OUT) {
26135                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
26136                 ndr->depth++;
26137                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
26138                 ndr->depth++;
26139                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
26140                 ndr->depth--;
26141                 ndr_print_WERROR(ndr, "result", r->out.result);
26142                 ndr->depth--;
26143         }
26144         ndr->depth--;
26145 }
26146
26147 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
26148 {
26149         if (flags & NDR_IN) {
26150                 if (r->in.handle == NULL) {
26151                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26152                 }
26153                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
26155                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
26156                 if (r->in.options) {
26157                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
26158                 }
26159         }
26160         if (flags & NDR_OUT) {
26161                 if (r->out.info == NULL) {
26162                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26163                 }
26164                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
26165                 if (*r->out.info) {
26166                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
26167                 }
26168                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26169         }
26170         return NDR_ERR_SUCCESS;
26171 }
26172
26173 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
26174 {
26175         uint32_t _ptr_options;
26176         uint32_t _ptr_info;
26177         TALLOC_CTX *_mem_save_handle_0;
26178         TALLOC_CTX *_mem_save_options_0;
26179         TALLOC_CTX *_mem_save_info_0;
26180         TALLOC_CTX *_mem_save_info_1;
26181         if (flags & NDR_IN) {
26182                 ZERO_STRUCT(r->out);
26183
26184                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26185                         NDR_PULL_ALLOC(ndr, r->in.handle);
26186                 }
26187                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26188                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26189                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26190                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
26192                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
26193                 if (_ptr_options) {
26194                         NDR_PULL_ALLOC(ndr, r->in.options);
26195                 } else {
26196                         r->in.options = NULL;
26197                 }
26198                 if (r->in.options) {
26199                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
26200                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
26201                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
26202                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
26203                 }
26204                 NDR_PULL_ALLOC(ndr, r->out.info);
26205                 ZERO_STRUCTP(r->out.info);
26206         }
26207         if (flags & NDR_OUT) {
26208                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26209                         NDR_PULL_ALLOC(ndr, r->out.info);
26210                 }
26211                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26212                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
26213                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
26214                 if (_ptr_info) {
26215                         NDR_PULL_ALLOC(ndr, *r->out.info);
26216                 } else {
26217                         *r->out.info = NULL;
26218                 }
26219                 if (*r->out.info) {
26220                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
26221                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
26222                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
26223                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
26224                 }
26225                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
26226                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26227         }
26228         return NDR_ERR_SUCCESS;
26229 }
26230
26231 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
26232 {
26233         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
26234         ndr->depth++;
26235         if (flags & NDR_SET_VALUES) {
26236                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26237         }
26238         if (flags & NDR_IN) {
26239                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
26240                 ndr->depth++;
26241                 ndr_print_ptr(ndr, "handle", r->in.handle);
26242                 ndr->depth++;
26243                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26244                 ndr->depth--;
26245                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
26246                 ndr_print_ptr(ndr, "options", r->in.options);
26247                 ndr->depth++;
26248                 if (r->in.options) {
26249                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
26250                 }
26251                 ndr->depth--;
26252                 ndr->depth--;
26253         }
26254         if (flags & NDR_OUT) {
26255                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
26256                 ndr->depth++;
26257                 ndr_print_ptr(ndr, "info", r->out.info);
26258                 ndr->depth++;
26259                 ndr_print_ptr(ndr, "info", *r->out.info);
26260                 ndr->depth++;
26261                 if (*r->out.info) {
26262                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
26263                 }
26264                 ndr->depth--;
26265                 ndr->depth--;
26266                 ndr_print_WERROR(ndr, "result", r->out.result);
26267                 ndr->depth--;
26268         }
26269         ndr->depth--;
26270 }
26271
26272 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
26273 {
26274         if (flags & NDR_IN) {
26275         }
26276         if (flags & NDR_OUT) {
26277                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26278         }
26279         return NDR_ERR_SUCCESS;
26280 }
26281
26282 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
26283 {
26284         if (flags & NDR_IN) {
26285         }
26286         if (flags & NDR_OUT) {
26287                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26288         }
26289         return NDR_ERR_SUCCESS;
26290 }
26291
26292 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
26293 {
26294         ndr_print_struct(ndr, name, "spoolss_44");
26295         ndr->depth++;
26296         if (flags & NDR_SET_VALUES) {
26297                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26298         }
26299         if (flags & NDR_IN) {
26300                 ndr_print_struct(ndr, "in", "spoolss_44");
26301                 ndr->depth++;
26302                 ndr->depth--;
26303         }
26304         if (flags & NDR_OUT) {
26305                 ndr_print_struct(ndr, "out", "spoolss_44");
26306                 ndr->depth++;
26307                 ndr_print_WERROR(ndr, "result", r->out.result);
26308                 ndr->depth--;
26309         }
26310         ndr->depth--;
26311 }
26312
26313 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
26314 {
26315         if (flags & NDR_IN) {
26316                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
26317                 if (r->in.printername) {
26318                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
26319                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26320                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
26321                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26322                 }
26323                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
26324                 if (r->in.datatype) {
26325                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
26326                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26327                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
26328                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26329                 }
26330                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
26331                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
26332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26333                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
26334                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
26335         }
26336         if (flags & NDR_OUT) {
26337                 if (r->out.handle == NULL) {
26338                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26339                 }
26340                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26341                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26342         }
26343         return NDR_ERR_SUCCESS;
26344 }
26345
26346 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
26347 {
26348         uint32_t _ptr_printername;
26349         uint32_t _ptr_datatype;
26350         TALLOC_CTX *_mem_save_printername_0;
26351         TALLOC_CTX *_mem_save_datatype_0;
26352         TALLOC_CTX *_mem_save_handle_0;
26353         if (flags & NDR_IN) {
26354                 ZERO_STRUCT(r->out);
26355
26356                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
26357                 if (_ptr_printername) {
26358                         NDR_PULL_ALLOC(ndr, r->in.printername);
26359                 } else {
26360                         r->in.printername = NULL;
26361                 }
26362                 if (r->in.printername) {
26363                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
26364                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
26365                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
26366                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
26367                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
26368                                 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));
26369                         }
26370                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
26371                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
26372                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
26373                 }
26374                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
26375                 if (_ptr_datatype) {
26376                         NDR_PULL_ALLOC(ndr, r->in.datatype);
26377                 } else {
26378                         r->in.datatype = NULL;
26379                 }
26380                 if (r->in.datatype) {
26381                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
26382                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
26383                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
26384                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
26385                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
26386                                 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));
26387                         }
26388                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
26389                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
26390                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
26391                 }
26392                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
26393                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
26394                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26395                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
26396                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
26397                 NDR_PULL_ALLOC(ndr, r->out.handle);
26398                 ZERO_STRUCTP(r->out.handle);
26399         }
26400         if (flags & NDR_OUT) {
26401                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26402                         NDR_PULL_ALLOC(ndr, r->out.handle);
26403                 }
26404                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26405                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26406                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26407                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26408                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26409         }
26410         return NDR_ERR_SUCCESS;
26411 }
26412
26413 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
26414 {
26415         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
26416         ndr->depth++;
26417         if (flags & NDR_SET_VALUES) {
26418                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26419         }
26420         if (flags & NDR_IN) {
26421                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
26422                 ndr->depth++;
26423                 ndr_print_ptr(ndr, "printername", r->in.printername);
26424                 ndr->depth++;
26425                 if (r->in.printername) {
26426                         ndr_print_string(ndr, "printername", r->in.printername);
26427                 }
26428                 ndr->depth--;
26429                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
26430                 ndr->depth++;
26431                 if (r->in.datatype) {
26432                         ndr_print_string(ndr, "datatype", r->in.datatype);
26433                 }
26434                 ndr->depth--;
26435                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
26436                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
26437                 ndr_print_uint32(ndr, "level", r->in.level);
26438                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
26439                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
26440                 ndr->depth--;
26441         }
26442         if (flags & NDR_OUT) {
26443                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
26444                 ndr->depth++;
26445                 ndr_print_ptr(ndr, "handle", r->out.handle);
26446                 ndr->depth++;
26447                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26448                 ndr->depth--;
26449                 ndr_print_WERROR(ndr, "result", r->out.result);
26450                 ndr->depth--;
26451         }
26452         ndr->depth--;
26453 }
26454
26455 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
26456 {
26457         if (flags & NDR_IN) {
26458                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
26459                 if (r->in.server) {
26460                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26461                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26462                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26463                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26464                 }
26465                 if (r->in.info_ctr == NULL) {
26466                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26467                 }
26468                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26469                 if (r->in.devmode_ctr == NULL) {
26470                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26471                 }
26472                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26473                 if (r->in.secdesc_ctr == NULL) {
26474                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26475                 }
26476                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
26477                 if (r->in.userlevel_ctr == NULL) {
26478                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26479                 }
26480                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
26481         }
26482         if (flags & NDR_OUT) {
26483                 if (r->out.handle == NULL) {
26484                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26485                 }
26486                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26487                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26488         }
26489         return NDR_ERR_SUCCESS;
26490 }
26491
26492 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
26493 {
26494         uint32_t _ptr_server;
26495         TALLOC_CTX *_mem_save_server_0;
26496         TALLOC_CTX *_mem_save_info_ctr_0;
26497         TALLOC_CTX *_mem_save_devmode_ctr_0;
26498         TALLOC_CTX *_mem_save_secdesc_ctr_0;
26499         TALLOC_CTX *_mem_save_userlevel_ctr_0;
26500         TALLOC_CTX *_mem_save_handle_0;
26501         if (flags & NDR_IN) {
26502                 ZERO_STRUCT(r->out);
26503
26504                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
26505                 if (_ptr_server) {
26506                         NDR_PULL_ALLOC(ndr, r->in.server);
26507                 } else {
26508                         r->in.server = NULL;
26509                 }
26510                 if (r->in.server) {
26511                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
26512                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
26513                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
26514                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
26515                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
26516                                 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));
26517                         }
26518                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
26519                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
26520                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
26521                 }
26522                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26523                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
26524                 }
26525                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26526                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
26527                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26528                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26529                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26530                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
26531                 }
26532                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26533                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
26534                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26535                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26536                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26537                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
26538                 }
26539                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26540                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
26541                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
26542                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26543                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26544                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
26545                 }
26546                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26547                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
26548                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
26549                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26550                 NDR_PULL_ALLOC(ndr, r->out.handle);
26551                 ZERO_STRUCTP(r->out.handle);
26552         }
26553         if (flags & NDR_OUT) {
26554                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26555                         NDR_PULL_ALLOC(ndr, r->out.handle);
26556                 }
26557                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26558                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26559                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26560                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26561                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26562         }
26563         return NDR_ERR_SUCCESS;
26564 }
26565
26566 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
26567 {
26568         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
26569         ndr->depth++;
26570         if (flags & NDR_SET_VALUES) {
26571                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26572         }
26573         if (flags & NDR_IN) {
26574                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
26575                 ndr->depth++;
26576                 ndr_print_ptr(ndr, "server", r->in.server);
26577                 ndr->depth++;
26578                 if (r->in.server) {
26579                         ndr_print_string(ndr, "server", r->in.server);
26580                 }
26581                 ndr->depth--;
26582                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
26583                 ndr->depth++;
26584                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
26585                 ndr->depth--;
26586                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
26587                 ndr->depth++;
26588                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
26589                 ndr->depth--;
26590                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
26591                 ndr->depth++;
26592                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
26593                 ndr->depth--;
26594                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
26595                 ndr->depth++;
26596                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
26597                 ndr->depth--;
26598                 ndr->depth--;
26599         }
26600         if (flags & NDR_OUT) {
26601                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
26602                 ndr->depth++;
26603                 ndr_print_ptr(ndr, "handle", r->out.handle);
26604                 ndr->depth++;
26605                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26606                 ndr->depth--;
26607                 ndr_print_WERROR(ndr, "result", r->out.result);
26608                 ndr->depth--;
26609         }
26610         ndr->depth--;
26611 }
26612
26613 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
26614 {
26615         if (flags & NDR_IN) {
26616         }
26617         if (flags & NDR_OUT) {
26618                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26619         }
26620         return NDR_ERR_SUCCESS;
26621 }
26622
26623 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
26624 {
26625         if (flags & NDR_IN) {
26626         }
26627         if (flags & NDR_OUT) {
26628                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26629         }
26630         return NDR_ERR_SUCCESS;
26631 }
26632
26633 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
26634 {
26635         ndr_print_struct(ndr, name, "spoolss_47");
26636         ndr->depth++;
26637         if (flags & NDR_SET_VALUES) {
26638                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26639         }
26640         if (flags & NDR_IN) {
26641                 ndr_print_struct(ndr, "in", "spoolss_47");
26642                 ndr->depth++;
26643                 ndr->depth--;
26644         }
26645         if (flags & NDR_OUT) {
26646                 ndr_print_struct(ndr, "out", "spoolss_47");
26647                 ndr->depth++;
26648                 ndr_print_WERROR(ndr, "result", r->out.result);
26649                 ndr->depth--;
26650         }
26651         ndr->depth--;
26652 }
26653
26654 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
26655 {
26656         if (flags & NDR_IN) {
26657                 if (r->in.handle == NULL) {
26658                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26659                 }
26660                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
26662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
26663                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
26664         }
26665         if (flags & NDR_OUT) {
26666                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
26667                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
26668                 if (r->out.value_needed == NULL) {
26669                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26670                 }
26671                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
26672                 if (r->out.type == NULL) {
26673                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26674                 }
26675                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
26676                 {
26677                         uint32_t _flags_save_uint8 = ndr->flags;
26678                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
26679                         if (r->out.data == NULL) {
26680                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26681                         }
26682                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
26683                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
26684                         ndr->flags = _flags_save_uint8;
26685                 }
26686                 if (r->out.data_needed == NULL) {
26687                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26688                 }
26689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
26690                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26691         }
26692         return NDR_ERR_SUCCESS;
26693 }
26694
26695 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
26696 {
26697         TALLOC_CTX *_mem_save_handle_0;
26698         TALLOC_CTX *_mem_save_value_needed_0;
26699         TALLOC_CTX *_mem_save_type_0;
26700         TALLOC_CTX *_mem_save_data_needed_0;
26701         if (flags & NDR_IN) {
26702                 ZERO_STRUCT(r->out);
26703
26704                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26705                         NDR_PULL_ALLOC(ndr, r->in.handle);
26706                 }
26707                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26708                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26709                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26710                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26711                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
26712                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
26713                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
26714                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
26715                 ZERO_STRUCTP(r->out.value_needed);
26716                 NDR_PULL_ALLOC(ndr, r->out.type);
26717                 ZERO_STRUCTP(r->out.type);
26718                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
26719                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
26720                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
26721                 ZERO_STRUCTP(r->out.data_needed);
26722         }
26723         if (flags & NDR_OUT) {
26724                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
26725                 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));
26726                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26727                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
26728                 }
26729                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26730                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
26731                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
26732                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
26733                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26734                         NDR_PULL_ALLOC(ndr, r->out.type);
26735                 }
26736                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26737                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
26738                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
26739                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
26740                 {
26741                         uint32_t _flags_save_uint8 = ndr->flags;
26742                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
26743                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
26744                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26745                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
26746                         }
26747                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
26748                         ndr->flags = _flags_save_uint8;
26749                 }
26750                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26751                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
26752                 }
26753                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26754                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
26755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
26756                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
26757                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26758                 if (r->out.value_name) {
26759                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
26760                 }
26761                 if (r->out.data) {
26762                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
26763                 }
26764         }
26765         return NDR_ERR_SUCCESS;
26766 }
26767
26768 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
26769 {
26770         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
26771         ndr->depth++;
26772         if (flags & NDR_SET_VALUES) {
26773                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26774         }
26775         if (flags & NDR_IN) {
26776                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
26777                 ndr->depth++;
26778                 ndr_print_ptr(ndr, "handle", r->in.handle);
26779                 ndr->depth++;
26780                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26781                 ndr->depth--;
26782                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
26783                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
26784                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
26785                 ndr->depth--;
26786         }
26787         if (flags & NDR_OUT) {
26788                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
26789                 ndr->depth++;
26790                 ndr_print_string(ndr, "value_name", r->out.value_name);
26791                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
26792                 ndr->depth++;
26793                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
26794                 ndr->depth--;
26795                 ndr_print_ptr(ndr, "type", r->out.type);
26796                 ndr->depth++;
26797                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
26798                 ndr->depth--;
26799                 ndr_print_ptr(ndr, "data", r->out.data);
26800                 ndr->depth++;
26801                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
26802                 ndr->depth--;
26803                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
26804                 ndr->depth++;
26805                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
26806                 ndr->depth--;
26807                 ndr_print_WERROR(ndr, "result", r->out.result);
26808                 ndr->depth--;
26809         }
26810         ndr->depth--;
26811 }
26812
26813 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
26814 {
26815         if (flags & NDR_IN) {
26816                 if (r->in.handle == NULL) {
26817                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26818                 }
26819                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26821                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26822                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26823                 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));
26824         }
26825         if (flags & NDR_OUT) {
26826                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26827         }
26828         return NDR_ERR_SUCCESS;
26829 }
26830
26831 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
26832 {
26833         TALLOC_CTX *_mem_save_handle_0;
26834         if (flags & NDR_IN) {
26835                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26836                         NDR_PULL_ALLOC(ndr, r->in.handle);
26837                 }
26838                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26839                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26840                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26841                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26842                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26843                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26844                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26845                         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));
26846                 }
26847                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26848                 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));
26849         }
26850         if (flags & NDR_OUT) {
26851                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26852         }
26853         return NDR_ERR_SUCCESS;
26854 }
26855
26856 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
26857 {
26858         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
26859         ndr->depth++;
26860         if (flags & NDR_SET_VALUES) {
26861                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26862         }
26863         if (flags & NDR_IN) {
26864                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
26865                 ndr->depth++;
26866                 ndr_print_ptr(ndr, "handle", r->in.handle);
26867                 ndr->depth++;
26868                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26869                 ndr->depth--;
26870                 ndr_print_string(ndr, "value_name", r->in.value_name);
26871                 ndr->depth--;
26872         }
26873         if (flags & NDR_OUT) {
26874                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
26875                 ndr->depth++;
26876                 ndr_print_WERROR(ndr, "result", r->out.result);
26877                 ndr->depth--;
26878         }
26879         ndr->depth--;
26880 }
26881
26882 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
26883 {
26884         if (flags & NDR_IN) {
26885         }
26886         if (flags & NDR_OUT) {
26887                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26888         }
26889         return NDR_ERR_SUCCESS;
26890 }
26891
26892 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
26893 {
26894         if (flags & NDR_IN) {
26895         }
26896         if (flags & NDR_OUT) {
26897                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26898         }
26899         return NDR_ERR_SUCCESS;
26900 }
26901
26902 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
26903 {
26904         ndr_print_struct(ndr, name, "spoolss_4a");
26905         ndr->depth++;
26906         if (flags & NDR_SET_VALUES) {
26907                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26908         }
26909         if (flags & NDR_IN) {
26910                 ndr_print_struct(ndr, "in", "spoolss_4a");
26911                 ndr->depth++;
26912                 ndr->depth--;
26913         }
26914         if (flags & NDR_OUT) {
26915                 ndr_print_struct(ndr, "out", "spoolss_4a");
26916                 ndr->depth++;
26917                 ndr_print_WERROR(ndr, "result", r->out.result);
26918                 ndr->depth--;
26919         }
26920         ndr->depth--;
26921 }
26922
26923 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
26924 {
26925         if (flags & NDR_IN) {
26926         }
26927         if (flags & NDR_OUT) {
26928                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26929         }
26930         return NDR_ERR_SUCCESS;
26931 }
26932
26933 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
26934 {
26935         if (flags & NDR_IN) {
26936         }
26937         if (flags & NDR_OUT) {
26938                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26939         }
26940         return NDR_ERR_SUCCESS;
26941 }
26942
26943 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
26944 {
26945         ndr_print_struct(ndr, name, "spoolss_4b");
26946         ndr->depth++;
26947         if (flags & NDR_SET_VALUES) {
26948                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26949         }
26950         if (flags & NDR_IN) {
26951                 ndr_print_struct(ndr, "in", "spoolss_4b");
26952                 ndr->depth++;
26953                 ndr->depth--;
26954         }
26955         if (flags & NDR_OUT) {
26956                 ndr_print_struct(ndr, "out", "spoolss_4b");
26957                 ndr->depth++;
26958                 ndr_print_WERROR(ndr, "result", r->out.result);
26959                 ndr->depth--;
26960         }
26961         ndr->depth--;
26962 }
26963
26964 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
26965 {
26966         if (flags & NDR_IN) {
26967         }
26968         if (flags & NDR_OUT) {
26969                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26970         }
26971         return NDR_ERR_SUCCESS;
26972 }
26973
26974 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
26975 {
26976         if (flags & NDR_IN) {
26977         }
26978         if (flags & NDR_OUT) {
26979                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26980         }
26981         return NDR_ERR_SUCCESS;
26982 }
26983
26984 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
26985 {
26986         ndr_print_struct(ndr, name, "spoolss_4c");
26987         ndr->depth++;
26988         if (flags & NDR_SET_VALUES) {
26989                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26990         }
26991         if (flags & NDR_IN) {
26992                 ndr_print_struct(ndr, "in", "spoolss_4c");
26993                 ndr->depth++;
26994                 ndr->depth--;
26995         }
26996         if (flags & NDR_OUT) {
26997                 ndr_print_struct(ndr, "out", "spoolss_4c");
26998                 ndr->depth++;
26999                 ndr_print_WERROR(ndr, "result", r->out.result);
27000                 ndr->depth--;
27001         }
27002         ndr->depth--;
27003 }
27004
27005 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
27006 {
27007         if (flags & NDR_IN) {
27008                 if (r->in.handle == NULL) {
27009                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27010                 }
27011                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27012                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27013                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27014                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27015                 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));
27016                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27018                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27019                 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));
27020                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
27021                 if (r->in.buffer == NULL) {
27022                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27023                 }
27024                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27025                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
27026                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27027         }
27028         if (flags & NDR_OUT) {
27029                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27030         }
27031         return NDR_ERR_SUCCESS;
27032 }
27033
27034 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
27035 {
27036         TALLOC_CTX *_mem_save_handle_0;
27037         if (flags & NDR_IN) {
27038                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27039                         NDR_PULL_ALLOC(ndr, r->in.handle);
27040                 }
27041                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27042                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27043                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27044                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27045                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27046                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27047                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27048                         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));
27049                 }
27050                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27051                 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));
27052                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27053                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27054                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27055                         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));
27056                 }
27057                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27058                 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));
27059                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
27060                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
27061                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27062                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
27063                 }
27064                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
27065                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27066                 if (r->in.buffer) {
27067                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
27068                 }
27069         }
27070         if (flags & NDR_OUT) {
27071                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27072         }
27073         return NDR_ERR_SUCCESS;
27074 }
27075
27076 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
27077 {
27078         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
27079         ndr->depth++;
27080         if (flags & NDR_SET_VALUES) {
27081                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27082         }
27083         if (flags & NDR_IN) {
27084                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
27085                 ndr->depth++;
27086                 ndr_print_ptr(ndr, "handle", r->in.handle);
27087                 ndr->depth++;
27088                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27089                 ndr->depth--;
27090                 ndr_print_string(ndr, "key_name", r->in.key_name);
27091                 ndr_print_string(ndr, "value_name", r->in.value_name);
27092                 ndr_print_winreg_Type(ndr, "type", r->in.type);
27093                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
27094                 ndr->depth++;
27095                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
27096                 ndr->depth--;
27097                 ndr_print_uint32(ndr, "offered", r->in.offered);
27098                 ndr->depth--;
27099         }
27100         if (flags & NDR_OUT) {
27101                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
27102                 ndr->depth++;
27103                 ndr_print_WERROR(ndr, "result", r->out.result);
27104                 ndr->depth--;
27105         }
27106         ndr->depth--;
27107 }
27108
27109 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
27110 {
27111         if (flags & NDR_IN) {
27112                 if (r->in.handle == NULL) {
27113                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27114                 }
27115                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27119                 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));
27120                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27121                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27122                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27123                 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));
27124                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27125         }
27126         if (flags & NDR_OUT) {
27127                 if (r->out.type == NULL) {
27128                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27129                 }
27130                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
27131                 if (r->out.buffer == NULL) {
27132                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27133                 }
27134                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27135                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
27136                 if (r->out.needed == NULL) {
27137                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27138                 }
27139                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27140                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27141         }
27142         return NDR_ERR_SUCCESS;
27143 }
27144
27145 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
27146 {
27147         TALLOC_CTX *_mem_save_handle_0;
27148         TALLOC_CTX *_mem_save_type_0;
27149         TALLOC_CTX *_mem_save_needed_0;
27150         if (flags & NDR_IN) {
27151                 ZERO_STRUCT(r->out);
27152
27153                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27154                         NDR_PULL_ALLOC(ndr, r->in.handle);
27155                 }
27156                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27157                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27158                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27159                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27160                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27161                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27162                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27163                         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));
27164                 }
27165                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27166                 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));
27167                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27168                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27169                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27170                         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));
27171                 }
27172                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27173                 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));
27174                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27175                 NDR_PULL_ALLOC(ndr, r->out.type);
27176                 ZERO_STRUCTP(r->out.type);
27177                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
27178                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
27179                 NDR_PULL_ALLOC(ndr, r->out.needed);
27180                 ZERO_STRUCTP(r->out.needed);
27181         }
27182         if (flags & NDR_OUT) {
27183                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27184                         NDR_PULL_ALLOC(ndr, r->out.type);
27185                 }
27186                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
27187                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
27188                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
27189                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
27190                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
27191                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27192                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
27193                 }
27194                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
27195                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27196                         NDR_PULL_ALLOC(ndr, r->out.needed);
27197                 }
27198                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27199                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27200                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27201                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27202                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27203                 if (r->out.buffer) {
27204                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
27205                 }
27206         }
27207         return NDR_ERR_SUCCESS;
27208 }
27209
27210 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
27211 {
27212         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
27213         ndr->depth++;
27214         if (flags & NDR_SET_VALUES) {
27215                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27216         }
27217         if (flags & NDR_IN) {
27218                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
27219                 ndr->depth++;
27220                 ndr_print_ptr(ndr, "handle", r->in.handle);
27221                 ndr->depth++;
27222                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27223                 ndr->depth--;
27224                 ndr_print_string(ndr, "key_name", r->in.key_name);
27225                 ndr_print_string(ndr, "value_name", r->in.value_name);
27226                 ndr_print_uint32(ndr, "offered", r->in.offered);
27227                 ndr->depth--;
27228         }
27229         if (flags & NDR_OUT) {
27230                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
27231                 ndr->depth++;
27232                 ndr_print_ptr(ndr, "type", r->out.type);
27233                 ndr->depth++;
27234                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
27235                 ndr->depth--;
27236                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
27237                 ndr->depth++;
27238                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
27239                 ndr->depth--;
27240                 ndr_print_ptr(ndr, "needed", r->out.needed);
27241                 ndr->depth++;
27242                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27243                 ndr->depth--;
27244                 ndr_print_WERROR(ndr, "result", r->out.result);
27245                 ndr->depth--;
27246         }
27247         ndr->depth--;
27248 }
27249
27250 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
27251 {
27252         if (flags & NDR_IN) {
27253                 if (r->in.handle == NULL) {
27254                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27255                 }
27256                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27258                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27260                 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));
27261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27262         }
27263         if (flags & NDR_OUT) {
27264                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
27265                 if (r->out.needed == NULL) {
27266                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27267                 }
27268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27269                 if (r->out.count == NULL) {
27270                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27271                 }
27272                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
27273                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27274         }
27275         return NDR_ERR_SUCCESS;
27276 }
27277
27278 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
27279 {
27280         TALLOC_CTX *_mem_save_handle_0;
27281         TALLOC_CTX *_mem_save_needed_0;
27282         TALLOC_CTX *_mem_save_count_0;
27283         if (flags & NDR_IN) {
27284                 ZERO_STRUCT(r->out);
27285
27286                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27287                         NDR_PULL_ALLOC(ndr, r->in.handle);
27288                 }
27289                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27290                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27291                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27292                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27293                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27294                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27295                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27296                         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));
27297                 }
27298                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27299                 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));
27300                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27301                 NDR_PULL_ALLOC(ndr, r->out.needed);
27302                 ZERO_STRUCTP(r->out.needed);
27303                 NDR_PULL_ALLOC(ndr, r->out.count);
27304                 ZERO_STRUCTP(r->out.count);
27305         }
27306         if (flags & NDR_OUT) {
27307                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
27308                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27309                         NDR_PULL_ALLOC(ndr, r->out.needed);
27310                 }
27311                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27312                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27314                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27315                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27316                         NDR_PULL_ALLOC(ndr, r->out.count);
27317                 }
27318                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
27319                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
27320                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
27321                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
27322                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27323         }
27324         return NDR_ERR_SUCCESS;
27325 }
27326
27327 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
27328 {
27329         uint32_t cntr_info_0;
27330         if (flags & NDR_IN) {
27331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
27332         }
27333         if (flags & NDR_OUT) {
27334                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27335                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
27336                 }
27337                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27338                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
27339                 }
27340         }
27341         return NDR_ERR_SUCCESS;
27342 }
27343
27344 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
27345 {
27346         uint32_t cntr_info_0;
27347         TALLOC_CTX *_mem_save_info_0;
27348         if (flags & NDR_IN) {
27349                 ZERO_STRUCT(r->out);
27350
27351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
27352         }
27353         if (flags & NDR_OUT) {
27354                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
27355                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
27356                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
27357                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27358                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
27359                 }
27360                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27361                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
27362                 }
27363                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
27364         }
27365         return NDR_ERR_SUCCESS;
27366 }
27367
27368 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
27369 {
27370         uint32_t cntr_info_2;
27371         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
27372         ndr->depth++;
27373         if (flags & NDR_SET_VALUES) {
27374                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27375         }
27376         if (flags & NDR_IN) {
27377                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
27378                 ndr->depth++;
27379                 ndr_print_ptr(ndr, "handle", r->in.handle);
27380                 ndr->depth++;
27381                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27382                 ndr->depth--;
27383                 ndr_print_string(ndr, "key_name", r->in.key_name);
27384                 ndr_print_uint32(ndr, "offered", r->in.offered);
27385                 ndr->depth--;
27386         }
27387         if (flags & NDR_OUT) {
27388                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
27389                 ndr->depth++;
27390                 ndr_print_ptr(ndr, "count", r->out.count);
27391                 ndr->depth++;
27392                 ndr_print_uint32(ndr, "count", *r->out.count);
27393                 ndr->depth--;
27394                 ndr_print_ptr(ndr, "info", r->out.info);
27395                 ndr->depth++;
27396                 ndr_print_ptr(ndr, "info", *r->out.info);
27397                 ndr->depth++;
27398                 if (*r->out.info) {
27399                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
27400                         ndr->depth++;
27401                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
27402                                 char *idx_2=NULL;
27403                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
27404                                         ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
27405                                         free(idx_2);
27406                                 }
27407                         }
27408                         ndr->depth--;
27409                 }
27410                 ndr->depth--;
27411                 ndr->depth--;
27412                 ndr_print_ptr(ndr, "needed", r->out.needed);
27413                 ndr->depth++;
27414                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27415                 ndr->depth--;
27416                 ndr_print_WERROR(ndr, "result", r->out.result);
27417                 ndr->depth--;
27418         }
27419         ndr->depth--;
27420 }
27421
27422 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
27423 {
27424         if (flags & NDR_IN) {
27425                 if (r->in.handle == NULL) {
27426                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27427                 }
27428                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27429                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27430                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27432                 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));
27433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27434         }
27435         if (flags & NDR_OUT) {
27436                 {
27437                         uint32_t _flags_save_string_array = ndr->flags;
27438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
27439                         if (r->out.key_buffer == NULL) {
27440                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27441                         }
27442                         NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.key_buffer));
27443                         if (*r->out.key_buffer) {
27444                                 {
27445                                         struct ndr_push *_ndr_key_buffer;
27446                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, r->in.offered));
27447                                         NDR_CHECK(ndr_push_string_array(_ndr_key_buffer, NDR_SCALARS, *r->out.key_buffer));
27448                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, r->in.offered));
27449                                 }
27450                         }
27451                         ndr->flags = _flags_save_string_array;
27452                 }
27453                 if (r->out.needed == NULL) {
27454                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27455                 }
27456                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27457                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27458         }
27459         return NDR_ERR_SUCCESS;
27460 }
27461
27462 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
27463 {
27464         uint32_t _ptr_key_buffer;
27465         TALLOC_CTX *_mem_save_handle_0;
27466         TALLOC_CTX *_mem_save_key_buffer_0;
27467         TALLOC_CTX *_mem_save_key_buffer_1;
27468         TALLOC_CTX *_mem_save_needed_0;
27469         if (flags & NDR_IN) {
27470                 ZERO_STRUCT(r->out);
27471
27472                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27473                         NDR_PULL_ALLOC(ndr, r->in.handle);
27474                 }
27475                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27476                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27477                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27478                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27479                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27480                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27481                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27482                         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));
27483                 }
27484                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27485                 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));
27486                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27487                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
27488                 ZERO_STRUCTP(r->out.key_buffer);
27489                 NDR_PULL_ALLOC(ndr, r->out.needed);
27490                 ZERO_STRUCTP(r->out.needed);
27491         }
27492         if (flags & NDR_OUT) {
27493                 {
27494                         uint32_t _flags_save_string_array = ndr->flags;
27495                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
27496                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27497                                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
27498                         }
27499                         _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
27500                         NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
27501                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_key_buffer));
27502                         if (_ptr_key_buffer) {
27503                                 NDR_PULL_ALLOC(ndr, *r->out.key_buffer);
27504                         } else {
27505                                 *r->out.key_buffer = NULL;
27506                         }
27507                         if (*r->out.key_buffer) {
27508                                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
27509                                 NDR_PULL_SET_MEM_CTX(ndr, *r->out.key_buffer, 0);
27510                                 {
27511                                         struct ndr_pull *_ndr_key_buffer;
27512                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, r->in.offered));
27513                                         NDR_CHECK(ndr_pull_string_array(_ndr_key_buffer, NDR_SCALARS, r->out.key_buffer));
27514                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, r->in.offered));
27515                                 }
27516                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
27517                         }
27518                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
27519                         ndr->flags = _flags_save_string_array;
27520                 }
27521                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27522                         NDR_PULL_ALLOC(ndr, r->out.needed);
27523                 }
27524                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27525                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27527                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27528                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27529         }
27530         return NDR_ERR_SUCCESS;
27531 }
27532
27533 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
27534 {
27535         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
27536         ndr->depth++;
27537         if (flags & NDR_SET_VALUES) {
27538                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27539         }
27540         if (flags & NDR_IN) {
27541                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
27542                 ndr->depth++;
27543                 ndr_print_ptr(ndr, "handle", r->in.handle);
27544                 ndr->depth++;
27545                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27546                 ndr->depth--;
27547                 ndr_print_string(ndr, "key_name", r->in.key_name);
27548                 ndr_print_uint32(ndr, "offered", r->in.offered);
27549                 ndr->depth--;
27550         }
27551         if (flags & NDR_OUT) {
27552                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
27553                 ndr->depth++;
27554                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
27555                 ndr->depth++;
27556                 ndr_print_ptr(ndr, "key_buffer", *r->out.key_buffer);
27557                 ndr->depth++;
27558                 if (*r->out.key_buffer) {
27559                         ndr_print_string_array(ndr, "key_buffer", *r->out.key_buffer);
27560                 }
27561                 ndr->depth--;
27562                 ndr->depth--;
27563                 ndr_print_ptr(ndr, "needed", r->out.needed);
27564                 ndr->depth++;
27565                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27566                 ndr->depth--;
27567                 ndr_print_WERROR(ndr, "result", r->out.result);
27568                 ndr->depth--;
27569         }
27570         ndr->depth--;
27571 }
27572
27573 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
27574 {
27575         if (flags & NDR_IN) {
27576                 if (r->in.handle == NULL) {
27577                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27578                 }
27579                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27580                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27581                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27582                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27583                 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));
27584                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27585                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27586                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27587                 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));
27588         }
27589         if (flags & NDR_OUT) {
27590                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27591         }
27592         return NDR_ERR_SUCCESS;
27593 }
27594
27595 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
27596 {
27597         TALLOC_CTX *_mem_save_handle_0;
27598         if (flags & NDR_IN) {
27599                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27600                         NDR_PULL_ALLOC(ndr, r->in.handle);
27601                 }
27602                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27603                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27604                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27605                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27606                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27607                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27608                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27609                         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));
27610                 }
27611                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27612                 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));
27613                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27614                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27615                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27616                         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));
27617                 }
27618                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27619                 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));
27620         }
27621         if (flags & NDR_OUT) {
27622                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27623         }
27624         return NDR_ERR_SUCCESS;
27625 }
27626
27627 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
27628 {
27629         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
27630         ndr->depth++;
27631         if (flags & NDR_SET_VALUES) {
27632                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27633         }
27634         if (flags & NDR_IN) {
27635                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
27636                 ndr->depth++;
27637                 ndr_print_ptr(ndr, "handle", r->in.handle);
27638                 ndr->depth++;
27639                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27640                 ndr->depth--;
27641                 ndr_print_string(ndr, "key_name", r->in.key_name);
27642                 ndr_print_string(ndr, "value_name", r->in.value_name);
27643                 ndr->depth--;
27644         }
27645         if (flags & NDR_OUT) {
27646                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
27647                 ndr->depth++;
27648                 ndr_print_WERROR(ndr, "result", r->out.result);
27649                 ndr->depth--;
27650         }
27651         ndr->depth--;
27652 }
27653
27654 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
27655 {
27656         if (flags & NDR_IN) {
27657                 if (r->in.handle == NULL) {
27658                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27659                 }
27660                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27663                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27664                 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));
27665         }
27666         if (flags & NDR_OUT) {
27667                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27668         }
27669         return NDR_ERR_SUCCESS;
27670 }
27671
27672 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
27673 {
27674         TALLOC_CTX *_mem_save_handle_0;
27675         if (flags & NDR_IN) {
27676                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27677                         NDR_PULL_ALLOC(ndr, r->in.handle);
27678                 }
27679                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27680                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27681                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27682                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27683                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27684                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27685                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27686                         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));
27687                 }
27688                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27689                 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));
27690         }
27691         if (flags & NDR_OUT) {
27692                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27693         }
27694         return NDR_ERR_SUCCESS;
27695 }
27696
27697 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
27698 {
27699         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
27700         ndr->depth++;
27701         if (flags & NDR_SET_VALUES) {
27702                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27703         }
27704         if (flags & NDR_IN) {
27705                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
27706                 ndr->depth++;
27707                 ndr_print_ptr(ndr, "handle", r->in.handle);
27708                 ndr->depth++;
27709                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27710                 ndr->depth--;
27711                 ndr_print_string(ndr, "key_name", r->in.key_name);
27712                 ndr->depth--;
27713         }
27714         if (flags & NDR_OUT) {
27715                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
27716                 ndr->depth++;
27717                 ndr_print_WERROR(ndr, "result", r->out.result);
27718                 ndr->depth--;
27719         }
27720         ndr->depth--;
27721 }
27722
27723 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
27724 {
27725         if (flags & NDR_IN) {
27726         }
27727         if (flags & NDR_OUT) {
27728                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27729         }
27730         return NDR_ERR_SUCCESS;
27731 }
27732
27733 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
27734 {
27735         if (flags & NDR_IN) {
27736         }
27737         if (flags & NDR_OUT) {
27738                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27739         }
27740         return NDR_ERR_SUCCESS;
27741 }
27742
27743 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
27744 {
27745         ndr_print_struct(ndr, name, "spoolss_53");
27746         ndr->depth++;
27747         if (flags & NDR_SET_VALUES) {
27748                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27749         }
27750         if (flags & NDR_IN) {
27751                 ndr_print_struct(ndr, "in", "spoolss_53");
27752                 ndr->depth++;
27753                 ndr->depth--;
27754         }
27755         if (flags & NDR_OUT) {
27756                 ndr_print_struct(ndr, "out", "spoolss_53");
27757                 ndr->depth++;
27758                 ndr_print_WERROR(ndr, "result", r->out.result);
27759                 ndr->depth--;
27760         }
27761         ndr->depth--;
27762 }
27763
27764 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
27765 {
27766         if (flags & NDR_IN) {
27767                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
27768                 if (r->in.server) {
27769                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27770                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27771                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27772                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27773                 }
27774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
27775                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
27777                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
27779                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27780                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
27781                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27782                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
27783                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
27784         }
27785         if (flags & NDR_OUT) {
27786                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27787         }
27788         return NDR_ERR_SUCCESS;
27789 }
27790
27791 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
27792 {
27793         uint32_t _ptr_server;
27794         TALLOC_CTX *_mem_save_server_0;
27795         if (flags & NDR_IN) {
27796                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
27797                 if (_ptr_server) {
27798                         NDR_PULL_ALLOC(ndr, r->in.server);
27799                 } else {
27800                         r->in.server = NULL;
27801                 }
27802                 if (r->in.server) {
27803                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
27804                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
27805                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
27806                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
27807                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
27808                                 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));
27809                         }
27810                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
27811                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
27812                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
27813                 }
27814                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
27815                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
27816                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
27817                         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));
27818                 }
27819                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
27820                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
27821                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
27822                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
27823                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
27824                         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));
27825                 }
27826                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
27827                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
27828                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
27829                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
27830         }
27831         if (flags & NDR_OUT) {
27832                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27833         }
27834         return NDR_ERR_SUCCESS;
27835 }
27836
27837 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
27838 {
27839         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
27840         ndr->depth++;
27841         if (flags & NDR_SET_VALUES) {
27842                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27843         }
27844         if (flags & NDR_IN) {
27845                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
27846                 ndr->depth++;
27847                 ndr_print_ptr(ndr, "server", r->in.server);
27848                 ndr->depth++;
27849                 if (r->in.server) {
27850                         ndr_print_string(ndr, "server", r->in.server);
27851                 }
27852                 ndr->depth--;
27853                 ndr_print_string(ndr, "architecture", r->in.architecture);
27854                 ndr_print_string(ndr, "driver", r->in.driver);
27855                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
27856                 ndr_print_uint32(ndr, "version", r->in.version);
27857                 ndr->depth--;
27858         }
27859         if (flags & NDR_OUT) {
27860                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
27861                 ndr->depth++;
27862                 ndr_print_WERROR(ndr, "result", r->out.result);
27863                 ndr->depth--;
27864         }
27865         ndr->depth--;
27866 }
27867
27868 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
27869 {
27870         if (flags & NDR_IN) {
27871         }
27872         if (flags & NDR_OUT) {
27873                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27874         }
27875         return NDR_ERR_SUCCESS;
27876 }
27877
27878 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
27879 {
27880         if (flags & NDR_IN) {
27881         }
27882         if (flags & NDR_OUT) {
27883                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27884         }
27885         return NDR_ERR_SUCCESS;
27886 }
27887
27888 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
27889 {
27890         ndr_print_struct(ndr, name, "spoolss_55");
27891         ndr->depth++;
27892         if (flags & NDR_SET_VALUES) {
27893                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27894         }
27895         if (flags & NDR_IN) {
27896                 ndr_print_struct(ndr, "in", "spoolss_55");
27897                 ndr->depth++;
27898                 ndr->depth--;
27899         }
27900         if (flags & NDR_OUT) {
27901                 ndr_print_struct(ndr, "out", "spoolss_55");
27902                 ndr->depth++;
27903                 ndr_print_WERROR(ndr, "result", r->out.result);
27904                 ndr->depth--;
27905         }
27906         ndr->depth--;
27907 }
27908
27909 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
27910 {
27911         if (flags & NDR_IN) {
27912         }
27913         if (flags & NDR_OUT) {
27914                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27915         }
27916         return NDR_ERR_SUCCESS;
27917 }
27918
27919 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
27920 {
27921         if (flags & NDR_IN) {
27922         }
27923         if (flags & NDR_OUT) {
27924                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27925         }
27926         return NDR_ERR_SUCCESS;
27927 }
27928
27929 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
27930 {
27931         ndr_print_struct(ndr, name, "spoolss_56");
27932         ndr->depth++;
27933         if (flags & NDR_SET_VALUES) {
27934                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27935         }
27936         if (flags & NDR_IN) {
27937                 ndr_print_struct(ndr, "in", "spoolss_56");
27938                 ndr->depth++;
27939                 ndr->depth--;
27940         }
27941         if (flags & NDR_OUT) {
27942                 ndr_print_struct(ndr, "out", "spoolss_56");
27943                 ndr->depth++;
27944                 ndr_print_WERROR(ndr, "result", r->out.result);
27945                 ndr->depth--;
27946         }
27947         ndr->depth--;
27948 }
27949
27950 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
27951 {
27952         if (flags & NDR_IN) {
27953         }
27954         if (flags & NDR_OUT) {
27955                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27956         }
27957         return NDR_ERR_SUCCESS;
27958 }
27959
27960 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
27961 {
27962         if (flags & NDR_IN) {
27963         }
27964         if (flags & NDR_OUT) {
27965                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27966         }
27967         return NDR_ERR_SUCCESS;
27968 }
27969
27970 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
27971 {
27972         ndr_print_struct(ndr, name, "spoolss_57");
27973         ndr->depth++;
27974         if (flags & NDR_SET_VALUES) {
27975                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27976         }
27977         if (flags & NDR_IN) {
27978                 ndr_print_struct(ndr, "in", "spoolss_57");
27979                 ndr->depth++;
27980                 ndr->depth--;
27981         }
27982         if (flags & NDR_OUT) {
27983                 ndr_print_struct(ndr, "out", "spoolss_57");
27984                 ndr->depth++;
27985                 ndr_print_WERROR(ndr, "result", r->out.result);
27986                 ndr->depth--;
27987         }
27988         ndr->depth--;
27989 }
27990
27991 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
27992 {
27993         if (flags & NDR_IN) {
27994                 if (r->in.handle == NULL) {
27995                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27996                 }
27997                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
27999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
28000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
28001                 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));
28002                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
28003                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
28004                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
28005                 if (r->in.status_code == NULL) {
28006                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28007                 }
28008                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
28009         }
28010         if (flags & NDR_OUT) {
28011                 if (r->out.out_data == NULL) {
28012                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28013                 }
28014                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
28015                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
28016                 if (r->out.needed == NULL) {
28017                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28018                 }
28019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28020                 if (r->out.status_code == NULL) {
28021                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28022                 }
28023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
28024                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28025         }
28026         return NDR_ERR_SUCCESS;
28027 }
28028
28029 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
28030 {
28031         TALLOC_CTX *_mem_save_handle_0;
28032         TALLOC_CTX *_mem_save_needed_0;
28033         TALLOC_CTX *_mem_save_status_code_0;
28034         if (flags & NDR_IN) {
28035                 ZERO_STRUCT(r->out);
28036
28037                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28038                         NDR_PULL_ALLOC(ndr, r->in.handle);
28039                 }
28040                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28041                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28042                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28043                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28044                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
28045                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
28046                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
28047                         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));
28048                 }
28049                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
28050                 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));
28051                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
28052                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
28053                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
28054                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28055                         NDR_PULL_ALLOC(ndr, r->in.status_code);
28056                 }
28057                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
28058                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
28059                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
28060                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
28061                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
28062                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
28063                 NDR_PULL_ALLOC(ndr, r->out.needed);
28064                 ZERO_STRUCTP(r->out.needed);
28065                 NDR_PULL_ALLOC(ndr, r->out.status_code);
28066                 *r->out.status_code = *r->in.status_code;
28067         }
28068         if (flags & NDR_OUT) {
28069                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
28070                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28071                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
28072                 }
28073                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
28074                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28075                         NDR_PULL_ALLOC(ndr, r->out.needed);
28076                 }
28077                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28078                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28079                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28080                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28081                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28082                         NDR_PULL_ALLOC(ndr, r->out.status_code);
28083                 }
28084                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
28085                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
28086                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
28087                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
28088                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28089                 if (r->out.out_data) {
28090                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
28091                 }
28092         }
28093         return NDR_ERR_SUCCESS;
28094 }
28095
28096 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
28097 {
28098         ndr_print_struct(ndr, name, "spoolss_XcvData");
28099         ndr->depth++;
28100         if (flags & NDR_SET_VALUES) {
28101                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28102         }
28103         if (flags & NDR_IN) {
28104                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
28105                 ndr->depth++;
28106                 ndr_print_ptr(ndr, "handle", r->in.handle);
28107                 ndr->depth++;
28108                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28109                 ndr->depth--;
28110                 ndr_print_string(ndr, "function_name", r->in.function_name);
28111                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
28112                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
28113                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
28114                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
28115                 ndr->depth++;
28116                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
28117                 ndr->depth--;
28118                 ndr->depth--;
28119         }
28120         if (flags & NDR_OUT) {
28121                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
28122                 ndr->depth++;
28123                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
28124                 ndr->depth++;
28125                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
28126                 ndr->depth--;
28127                 ndr_print_ptr(ndr, "needed", r->out.needed);
28128                 ndr->depth++;
28129                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28130                 ndr->depth--;
28131                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
28132                 ndr->depth++;
28133                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
28134                 ndr->depth--;
28135                 ndr_print_WERROR(ndr, "result", r->out.result);
28136                 ndr->depth--;
28137         }
28138         ndr->depth--;
28139 }
28140
28141 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
28142 {
28143         if (flags & NDR_IN) {
28144                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
28145                 if (r->in.servername) {
28146                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
28147                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
28148                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
28149                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28150                 }
28151                 if (r->in.info_ctr == NULL) {
28152                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28153                 }
28154                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
28155                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
28156         }
28157         if (flags & NDR_OUT) {
28158                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28159         }
28160         return NDR_ERR_SUCCESS;
28161 }
28162
28163 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
28164 {
28165         uint32_t _ptr_servername;
28166         TALLOC_CTX *_mem_save_servername_0;
28167         TALLOC_CTX *_mem_save_info_ctr_0;
28168         if (flags & NDR_IN) {
28169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
28170                 if (_ptr_servername) {
28171                         NDR_PULL_ALLOC(ndr, r->in.servername);
28172                 } else {
28173                         r->in.servername = NULL;
28174                 }
28175                 if (r->in.servername) {
28176                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
28177                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
28178                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
28179                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
28180                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
28181                                 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));
28182                         }
28183                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
28184                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
28185                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
28186                 }
28187                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28188                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
28189                 }
28190                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
28191                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
28192                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
28193                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
28194                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
28195         }
28196         if (flags & NDR_OUT) {
28197                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28198         }
28199         return NDR_ERR_SUCCESS;
28200 }
28201
28202 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
28203 {
28204         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
28205         ndr->depth++;
28206         if (flags & NDR_SET_VALUES) {
28207                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28208         }
28209         if (flags & NDR_IN) {
28210                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
28211                 ndr->depth++;
28212                 ndr_print_ptr(ndr, "servername", r->in.servername);
28213                 ndr->depth++;
28214                 if (r->in.servername) {
28215                         ndr_print_string(ndr, "servername", r->in.servername);
28216                 }
28217                 ndr->depth--;
28218                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
28219                 ndr->depth++;
28220                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
28221                 ndr->depth--;
28222                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
28223                 ndr->depth--;
28224         }
28225         if (flags & NDR_OUT) {
28226                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
28227                 ndr->depth++;
28228                 ndr_print_WERROR(ndr, "result", r->out.result);
28229                 ndr->depth--;
28230         }
28231         ndr->depth--;
28232 }
28233
28234 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
28235 {
28236         if (flags & NDR_IN) {
28237         }
28238         if (flags & NDR_OUT) {
28239                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28240         }
28241         return NDR_ERR_SUCCESS;
28242 }
28243
28244 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
28245 {
28246         if (flags & NDR_IN) {
28247         }
28248         if (flags & NDR_OUT) {
28249                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28250         }
28251         return NDR_ERR_SUCCESS;
28252 }
28253
28254 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
28255 {
28256         ndr_print_struct(ndr, name, "spoolss_5a");
28257         ndr->depth++;
28258         if (flags & NDR_SET_VALUES) {
28259                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28260         }
28261         if (flags & NDR_IN) {
28262                 ndr_print_struct(ndr, "in", "spoolss_5a");
28263                 ndr->depth++;
28264                 ndr->depth--;
28265         }
28266         if (flags & NDR_OUT) {
28267                 ndr_print_struct(ndr, "out", "spoolss_5a");
28268                 ndr->depth++;
28269                 ndr_print_WERROR(ndr, "result", r->out.result);
28270                 ndr->depth--;
28271         }
28272         ndr->depth--;
28273 }
28274
28275 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
28276 {
28277         if (flags & NDR_IN) {
28278         }
28279         if (flags & NDR_OUT) {
28280                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28281         }
28282         return NDR_ERR_SUCCESS;
28283 }
28284
28285 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
28286 {
28287         if (flags & NDR_IN) {
28288         }
28289         if (flags & NDR_OUT) {
28290                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28291         }
28292         return NDR_ERR_SUCCESS;
28293 }
28294
28295 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
28296 {
28297         ndr_print_struct(ndr, name, "spoolss_5b");
28298         ndr->depth++;
28299         if (flags & NDR_SET_VALUES) {
28300                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28301         }
28302         if (flags & NDR_IN) {
28303                 ndr_print_struct(ndr, "in", "spoolss_5b");
28304                 ndr->depth++;
28305                 ndr->depth--;
28306         }
28307         if (flags & NDR_OUT) {
28308                 ndr_print_struct(ndr, "out", "spoolss_5b");
28309                 ndr->depth++;
28310                 ndr_print_WERROR(ndr, "result", r->out.result);
28311                 ndr->depth--;
28312         }
28313         ndr->depth--;
28314 }
28315
28316 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
28317 {
28318         if (flags & NDR_IN) {
28319         }
28320         if (flags & NDR_OUT) {
28321                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28322         }
28323         return NDR_ERR_SUCCESS;
28324 }
28325
28326 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
28327 {
28328         if (flags & NDR_IN) {
28329         }
28330         if (flags & NDR_OUT) {
28331                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28332         }
28333         return NDR_ERR_SUCCESS;
28334 }
28335
28336 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
28337 {
28338         ndr_print_struct(ndr, name, "spoolss_5c");
28339         ndr->depth++;
28340         if (flags & NDR_SET_VALUES) {
28341                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28342         }
28343         if (flags & NDR_IN) {
28344                 ndr_print_struct(ndr, "in", "spoolss_5c");
28345                 ndr->depth++;
28346                 ndr->depth--;
28347         }
28348         if (flags & NDR_OUT) {
28349                 ndr_print_struct(ndr, "out", "spoolss_5c");
28350                 ndr->depth++;
28351                 ndr_print_WERROR(ndr, "result", r->out.result);
28352                 ndr->depth--;
28353         }
28354         ndr->depth--;
28355 }
28356
28357 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
28358 {
28359         if (flags & NDR_IN) {
28360         }
28361         if (flags & NDR_OUT) {
28362                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28363         }
28364         return NDR_ERR_SUCCESS;
28365 }
28366
28367 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
28368 {
28369         if (flags & NDR_IN) {
28370         }
28371         if (flags & NDR_OUT) {
28372                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28373         }
28374         return NDR_ERR_SUCCESS;
28375 }
28376
28377 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
28378 {
28379         ndr_print_struct(ndr, name, "spoolss_5d");
28380         ndr->depth++;
28381         if (flags & NDR_SET_VALUES) {
28382                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28383         }
28384         if (flags & NDR_IN) {
28385                 ndr_print_struct(ndr, "in", "spoolss_5d");
28386                 ndr->depth++;
28387                 ndr->depth--;
28388         }
28389         if (flags & NDR_OUT) {
28390                 ndr_print_struct(ndr, "out", "spoolss_5d");
28391                 ndr->depth++;
28392                 ndr_print_WERROR(ndr, "result", r->out.result);
28393                 ndr->depth--;
28394         }
28395         ndr->depth--;
28396 }
28397
28398 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
28399 {
28400         if (flags & NDR_IN) {
28401         }
28402         if (flags & NDR_OUT) {
28403                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28404         }
28405         return NDR_ERR_SUCCESS;
28406 }
28407
28408 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
28409 {
28410         if (flags & NDR_IN) {
28411         }
28412         if (flags & NDR_OUT) {
28413                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28414         }
28415         return NDR_ERR_SUCCESS;
28416 }
28417
28418 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
28419 {
28420         ndr_print_struct(ndr, name, "spoolss_5e");
28421         ndr->depth++;
28422         if (flags & NDR_SET_VALUES) {
28423                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28424         }
28425         if (flags & NDR_IN) {
28426                 ndr_print_struct(ndr, "in", "spoolss_5e");
28427                 ndr->depth++;
28428                 ndr->depth--;
28429         }
28430         if (flags & NDR_OUT) {
28431                 ndr_print_struct(ndr, "out", "spoolss_5e");
28432                 ndr->depth++;
28433                 ndr_print_WERROR(ndr, "result", r->out.result);
28434                 ndr->depth--;
28435         }
28436         ndr->depth--;
28437 }
28438
28439 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
28440 {
28441         if (flags & NDR_IN) {
28442         }
28443         if (flags & NDR_OUT) {
28444                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28445         }
28446         return NDR_ERR_SUCCESS;
28447 }
28448
28449 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
28450 {
28451         if (flags & NDR_IN) {
28452         }
28453         if (flags & NDR_OUT) {
28454                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28455         }
28456         return NDR_ERR_SUCCESS;
28457 }
28458
28459 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
28460 {
28461         ndr_print_struct(ndr, name, "spoolss_5f");
28462         ndr->depth++;
28463         if (flags & NDR_SET_VALUES) {
28464                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28465         }
28466         if (flags & NDR_IN) {
28467                 ndr_print_struct(ndr, "in", "spoolss_5f");
28468                 ndr->depth++;
28469                 ndr->depth--;
28470         }
28471         if (flags & NDR_OUT) {
28472                 ndr_print_struct(ndr, "out", "spoolss_5f");
28473                 ndr->depth++;
28474                 ndr_print_WERROR(ndr, "result", r->out.result);
28475                 ndr->depth--;
28476         }
28477         ndr->depth--;
28478 }
28479
28480 static const struct ndr_interface_call spoolss_calls[] = {
28481         {
28482                 "spoolss_EnumPrinters",
28483                 sizeof(struct spoolss_EnumPrinters),
28484                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
28485                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
28486                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
28487                 false,
28488         },
28489         {
28490                 "spoolss_OpenPrinter",
28491                 sizeof(struct spoolss_OpenPrinter),
28492                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
28493                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
28494                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
28495                 false,
28496         },
28497         {
28498                 "spoolss_SetJob",
28499                 sizeof(struct spoolss_SetJob),
28500                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
28501                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
28502                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
28503                 false,
28504         },
28505         {
28506                 "spoolss_GetJob",
28507                 sizeof(struct spoolss_GetJob),
28508                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
28509                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
28510                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
28511                 false,
28512         },
28513         {
28514                 "spoolss_EnumJobs",
28515                 sizeof(struct spoolss_EnumJobs),
28516                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
28517                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
28518                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
28519                 false,
28520         },
28521         {
28522                 "spoolss_AddPrinter",
28523                 sizeof(struct spoolss_AddPrinter),
28524                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
28525                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
28526                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
28527                 false,
28528         },
28529         {
28530                 "spoolss_DeletePrinter",
28531                 sizeof(struct spoolss_DeletePrinter),
28532                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
28533                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
28534                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
28535                 false,
28536         },
28537         {
28538                 "spoolss_SetPrinter",
28539                 sizeof(struct spoolss_SetPrinter),
28540                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
28541                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
28542                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
28543                 false,
28544         },
28545         {
28546                 "spoolss_GetPrinter",
28547                 sizeof(struct spoolss_GetPrinter),
28548                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
28549                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
28550                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
28551                 false,
28552         },
28553         {
28554                 "spoolss_AddPrinterDriver",
28555                 sizeof(struct spoolss_AddPrinterDriver),
28556                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
28557                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
28558                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
28559                 false,
28560         },
28561         {
28562                 "spoolss_EnumPrinterDrivers",
28563                 sizeof(struct spoolss_EnumPrinterDrivers),
28564                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
28565                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
28566                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
28567                 false,
28568         },
28569         {
28570                 "spoolss_GetPrinterDriver",
28571                 sizeof(struct spoolss_GetPrinterDriver),
28572                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
28573                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
28574                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
28575                 false,
28576         },
28577         {
28578                 "spoolss_GetPrinterDriverDirectory",
28579                 sizeof(struct spoolss_GetPrinterDriverDirectory),
28580                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
28581                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
28582                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
28583                 false,
28584         },
28585         {
28586                 "spoolss_DeletePrinterDriver",
28587                 sizeof(struct spoolss_DeletePrinterDriver),
28588                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
28589                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
28590                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
28591                 false,
28592         },
28593         {
28594                 "spoolss_AddPrintProcessor",
28595                 sizeof(struct spoolss_AddPrintProcessor),
28596                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
28597                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
28598                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
28599                 false,
28600         },
28601         {
28602                 "spoolss_EnumPrintProcessors",
28603                 sizeof(struct spoolss_EnumPrintProcessors),
28604                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
28605                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
28606                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
28607                 false,
28608         },
28609         {
28610                 "spoolss_GetPrintProcessorDirectory",
28611                 sizeof(struct spoolss_GetPrintProcessorDirectory),
28612                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
28613                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
28614                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
28615                 false,
28616         },
28617         {
28618                 "spoolss_StartDocPrinter",
28619                 sizeof(struct spoolss_StartDocPrinter),
28620                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
28621                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
28622                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
28623                 false,
28624         },
28625         {
28626                 "spoolss_StartPagePrinter",
28627                 sizeof(struct spoolss_StartPagePrinter),
28628                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
28629                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
28630                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
28631                 false,
28632         },
28633         {
28634                 "spoolss_WritePrinter",
28635                 sizeof(struct spoolss_WritePrinter),
28636                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
28637                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
28638                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
28639                 false,
28640         },
28641         {
28642                 "spoolss_EndPagePrinter",
28643                 sizeof(struct spoolss_EndPagePrinter),
28644                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
28645                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
28646                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
28647                 false,
28648         },
28649         {
28650                 "spoolss_AbortPrinter",
28651                 sizeof(struct spoolss_AbortPrinter),
28652                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
28653                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
28654                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
28655                 false,
28656         },
28657         {
28658                 "spoolss_ReadPrinter",
28659                 sizeof(struct spoolss_ReadPrinter),
28660                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
28661                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
28662                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
28663                 false,
28664         },
28665         {
28666                 "spoolss_EndDocPrinter",
28667                 sizeof(struct spoolss_EndDocPrinter),
28668                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
28669                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
28670                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
28671                 false,
28672         },
28673         {
28674                 "spoolss_AddJob",
28675                 sizeof(struct spoolss_AddJob),
28676                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
28677                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
28678                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
28679                 false,
28680         },
28681         {
28682                 "spoolss_ScheduleJob",
28683                 sizeof(struct spoolss_ScheduleJob),
28684                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
28685                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
28686                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
28687                 false,
28688         },
28689         {
28690                 "spoolss_GetPrinterData",
28691                 sizeof(struct spoolss_GetPrinterData),
28692                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
28693                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
28694                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
28695                 false,
28696         },
28697         {
28698                 "spoolss_SetPrinterData",
28699                 sizeof(struct spoolss_SetPrinterData),
28700                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
28701                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
28702                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
28703                 false,
28704         },
28705         {
28706                 "spoolss_WaitForPrinterChange",
28707                 sizeof(struct spoolss_WaitForPrinterChange),
28708                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
28709                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
28710                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
28711                 false,
28712         },
28713         {
28714                 "spoolss_ClosePrinter",
28715                 sizeof(struct spoolss_ClosePrinter),
28716                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
28717                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
28718                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
28719                 false,
28720         },
28721         {
28722                 "spoolss_AddForm",
28723                 sizeof(struct spoolss_AddForm),
28724                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
28725                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
28726                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
28727                 false,
28728         },
28729         {
28730                 "spoolss_DeleteForm",
28731                 sizeof(struct spoolss_DeleteForm),
28732                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
28733                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
28734                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
28735                 false,
28736         },
28737         {
28738                 "spoolss_GetForm",
28739                 sizeof(struct spoolss_GetForm),
28740                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
28741                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
28742                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
28743                 false,
28744         },
28745         {
28746                 "spoolss_SetForm",
28747                 sizeof(struct spoolss_SetForm),
28748                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
28749                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
28750                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
28751                 false,
28752         },
28753         {
28754                 "spoolss_EnumForms",
28755                 sizeof(struct spoolss_EnumForms),
28756                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
28757                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
28758                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
28759                 false,
28760         },
28761         {
28762                 "spoolss_EnumPorts",
28763                 sizeof(struct spoolss_EnumPorts),
28764                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
28765                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
28766                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
28767                 false,
28768         },
28769         {
28770                 "spoolss_EnumMonitors",
28771                 sizeof(struct spoolss_EnumMonitors),
28772                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
28773                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
28774                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
28775                 false,
28776         },
28777         {
28778                 "spoolss_AddPort",
28779                 sizeof(struct spoolss_AddPort),
28780                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
28781                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
28782                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
28783                 false,
28784         },
28785         {
28786                 "spoolss_ConfigurePort",
28787                 sizeof(struct spoolss_ConfigurePort),
28788                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
28789                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
28790                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
28791                 false,
28792         },
28793         {
28794                 "spoolss_DeletePort",
28795                 sizeof(struct spoolss_DeletePort),
28796                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
28797                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
28798                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
28799                 false,
28800         },
28801         {
28802                 "spoolss_CreatePrinterIC",
28803                 sizeof(struct spoolss_CreatePrinterIC),
28804                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
28805                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
28806                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
28807                 false,
28808         },
28809         {
28810                 "spoolss_PlayGDIScriptOnPrinterIC",
28811                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
28812                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
28813                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
28814                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
28815                 false,
28816         },
28817         {
28818                 "spoolss_DeletePrinterIC",
28819                 sizeof(struct spoolss_DeletePrinterIC),
28820                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
28821                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
28822                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
28823                 false,
28824         },
28825         {
28826                 "spoolss_AddPrinterConnection",
28827                 sizeof(struct spoolss_AddPrinterConnection),
28828                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
28829                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
28830                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
28831                 false,
28832         },
28833         {
28834                 "spoolss_DeletePrinterConnection",
28835                 sizeof(struct spoolss_DeletePrinterConnection),
28836                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
28837                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
28838                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
28839                 false,
28840         },
28841         {
28842                 "spoolss_PrinterMessageBox",
28843                 sizeof(struct spoolss_PrinterMessageBox),
28844                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
28845                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
28846                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
28847                 false,
28848         },
28849         {
28850                 "spoolss_AddMonitor",
28851                 sizeof(struct spoolss_AddMonitor),
28852                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
28853                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
28854                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
28855                 false,
28856         },
28857         {
28858                 "spoolss_DeleteMonitor",
28859                 sizeof(struct spoolss_DeleteMonitor),
28860                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
28861                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
28862                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
28863                 false,
28864         },
28865         {
28866                 "spoolss_DeletePrintProcessor",
28867                 sizeof(struct spoolss_DeletePrintProcessor),
28868                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
28869                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
28870                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
28871                 false,
28872         },
28873         {
28874                 "spoolss_AddPrintProvidor",
28875                 sizeof(struct spoolss_AddPrintProvidor),
28876                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
28877                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
28878                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
28879                 false,
28880         },
28881         {
28882                 "spoolss_DeletePrintProvidor",
28883                 sizeof(struct spoolss_DeletePrintProvidor),
28884                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
28885                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
28886                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
28887                 false,
28888         },
28889         {
28890                 "spoolss_EnumPrintProcDataTypes",
28891                 sizeof(struct spoolss_EnumPrintProcDataTypes),
28892                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
28893                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
28894                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
28895                 false,
28896         },
28897         {
28898                 "spoolss_ResetPrinter",
28899                 sizeof(struct spoolss_ResetPrinter),
28900                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
28901                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
28902                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
28903                 false,
28904         },
28905         {
28906                 "spoolss_GetPrinterDriver2",
28907                 sizeof(struct spoolss_GetPrinterDriver2),
28908                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
28909                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
28910                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
28911                 false,
28912         },
28913         {
28914                 "spoolss_FindFirstPrinterChangeNotification",
28915                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
28916                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
28917                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
28918                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
28919                 false,
28920         },
28921         {
28922                 "spoolss_FindNextPrinterChangeNotification",
28923                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
28924                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
28925                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
28926                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
28927                 false,
28928         },
28929         {
28930                 "spoolss_FindClosePrinterNotify",
28931                 sizeof(struct spoolss_FindClosePrinterNotify),
28932                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
28933                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
28934                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
28935                 false,
28936         },
28937         {
28938                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
28939                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
28940                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
28941                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
28942                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
28943                 false,
28944         },
28945         {
28946                 "spoolss_ReplyOpenPrinter",
28947                 sizeof(struct spoolss_ReplyOpenPrinter),
28948                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
28949                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
28950                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
28951                 false,
28952         },
28953         {
28954                 "spoolss_RouterReplyPrinter",
28955                 sizeof(struct spoolss_RouterReplyPrinter),
28956                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
28957                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
28958                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
28959                 false,
28960         },
28961         {
28962                 "spoolss_ReplyClosePrinter",
28963                 sizeof(struct spoolss_ReplyClosePrinter),
28964                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
28965                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
28966                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
28967                 false,
28968         },
28969         {
28970                 "spoolss_AddPortEx",
28971                 sizeof(struct spoolss_AddPortEx),
28972                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
28973                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
28974                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
28975                 false,
28976         },
28977         {
28978                 "spoolss_RouterFindFirstPrinterChangeNotification",
28979                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
28980                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
28981                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
28982                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
28983                 false,
28984         },
28985         {
28986                 "spoolss_SpoolerInit",
28987                 sizeof(struct spoolss_SpoolerInit),
28988                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
28989                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
28990                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
28991                 false,
28992         },
28993         {
28994                 "spoolss_ResetPrinterEx",
28995                 sizeof(struct spoolss_ResetPrinterEx),
28996                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
28997                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
28998                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
28999                 false,
29000         },
29001         {
29002                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
29003                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
29004                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
29005                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
29006                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
29007                 false,
29008         },
29009         {
29010                 "spoolss_RouterReplyPrinterEx",
29011                 sizeof(struct spoolss_RouterReplyPrinterEx),
29012                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
29013                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
29014                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
29015                 false,
29016         },
29017         {
29018                 "spoolss_RouterRefreshPrinterChangeNotify",
29019                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
29020                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
29021                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
29022                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
29023                 false,
29024         },
29025         {
29026                 "spoolss_44",
29027                 sizeof(struct spoolss_44),
29028                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
29029                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
29030                 (ndr_print_function_t) ndr_print_spoolss_44,
29031                 false,
29032         },
29033         {
29034                 "spoolss_OpenPrinterEx",
29035                 sizeof(struct spoolss_OpenPrinterEx),
29036                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
29037                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
29038                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
29039                 false,
29040         },
29041         {
29042                 "spoolss_AddPrinterEx",
29043                 sizeof(struct spoolss_AddPrinterEx),
29044                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
29045                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
29046                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
29047                 false,
29048         },
29049         {
29050                 "spoolss_47",
29051                 sizeof(struct spoolss_47),
29052                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
29053                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
29054                 (ndr_print_function_t) ndr_print_spoolss_47,
29055                 false,
29056         },
29057         {
29058                 "spoolss_EnumPrinterData",
29059                 sizeof(struct spoolss_EnumPrinterData),
29060                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
29061                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
29062                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
29063                 false,
29064         },
29065         {
29066                 "spoolss_DeletePrinterData",
29067                 sizeof(struct spoolss_DeletePrinterData),
29068                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
29069                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
29070                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
29071                 false,
29072         },
29073         {
29074                 "spoolss_4a",
29075                 sizeof(struct spoolss_4a),
29076                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
29077                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
29078                 (ndr_print_function_t) ndr_print_spoolss_4a,
29079                 false,
29080         },
29081         {
29082                 "spoolss_4b",
29083                 sizeof(struct spoolss_4b),
29084                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
29085                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
29086                 (ndr_print_function_t) ndr_print_spoolss_4b,
29087                 false,
29088         },
29089         {
29090                 "spoolss_4c",
29091                 sizeof(struct spoolss_4c),
29092                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
29093                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
29094                 (ndr_print_function_t) ndr_print_spoolss_4c,
29095                 false,
29096         },
29097         {
29098                 "spoolss_SetPrinterDataEx",
29099                 sizeof(struct spoolss_SetPrinterDataEx),
29100                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
29101                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
29102                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
29103                 false,
29104         },
29105         {
29106                 "spoolss_GetPrinterDataEx",
29107                 sizeof(struct spoolss_GetPrinterDataEx),
29108                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
29109                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
29110                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
29111                 false,
29112         },
29113         {
29114                 "spoolss_EnumPrinterDataEx",
29115                 sizeof(struct spoolss_EnumPrinterDataEx),
29116                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
29117                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
29118                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
29119                 false,
29120         },
29121         {
29122                 "spoolss_EnumPrinterKey",
29123                 sizeof(struct spoolss_EnumPrinterKey),
29124                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
29125                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
29126                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
29127                 false,
29128         },
29129         {
29130                 "spoolss_DeletePrinterDataEx",
29131                 sizeof(struct spoolss_DeletePrinterDataEx),
29132                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
29133                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
29134                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
29135                 false,
29136         },
29137         {
29138                 "spoolss_DeletePrinterKey",
29139                 sizeof(struct spoolss_DeletePrinterKey),
29140                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
29141                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
29142                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
29143                 false,
29144         },
29145         {
29146                 "spoolss_53",
29147                 sizeof(struct spoolss_53),
29148                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
29149                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
29150                 (ndr_print_function_t) ndr_print_spoolss_53,
29151                 false,
29152         },
29153         {
29154                 "spoolss_DeletePrinterDriverEx",
29155                 sizeof(struct spoolss_DeletePrinterDriverEx),
29156                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
29157                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
29158                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
29159                 false,
29160         },
29161         {
29162                 "spoolss_55",
29163                 sizeof(struct spoolss_55),
29164                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
29165                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
29166                 (ndr_print_function_t) ndr_print_spoolss_55,
29167                 false,
29168         },
29169         {
29170                 "spoolss_56",
29171                 sizeof(struct spoolss_56),
29172                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
29173                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
29174                 (ndr_print_function_t) ndr_print_spoolss_56,
29175                 false,
29176         },
29177         {
29178                 "spoolss_57",
29179                 sizeof(struct spoolss_57),
29180                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
29181                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
29182                 (ndr_print_function_t) ndr_print_spoolss_57,
29183                 false,
29184         },
29185         {
29186                 "spoolss_XcvData",
29187                 sizeof(struct spoolss_XcvData),
29188                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
29189                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
29190                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
29191                 false,
29192         },
29193         {
29194                 "spoolss_AddPrinterDriverEx",
29195                 sizeof(struct spoolss_AddPrinterDriverEx),
29196                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
29197                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
29198                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
29199                 false,
29200         },
29201         {
29202                 "spoolss_5a",
29203                 sizeof(struct spoolss_5a),
29204                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
29205                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
29206                 (ndr_print_function_t) ndr_print_spoolss_5a,
29207                 false,
29208         },
29209         {
29210                 "spoolss_5b",
29211                 sizeof(struct spoolss_5b),
29212                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
29213                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
29214                 (ndr_print_function_t) ndr_print_spoolss_5b,
29215                 false,
29216         },
29217         {
29218                 "spoolss_5c",
29219                 sizeof(struct spoolss_5c),
29220                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
29221                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
29222                 (ndr_print_function_t) ndr_print_spoolss_5c,
29223                 false,
29224         },
29225         {
29226                 "spoolss_5d",
29227                 sizeof(struct spoolss_5d),
29228                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
29229                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
29230                 (ndr_print_function_t) ndr_print_spoolss_5d,
29231                 false,
29232         },
29233         {
29234                 "spoolss_5e",
29235                 sizeof(struct spoolss_5e),
29236                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
29237                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
29238                 (ndr_print_function_t) ndr_print_spoolss_5e,
29239                 false,
29240         },
29241         {
29242                 "spoolss_5f",
29243                 sizeof(struct spoolss_5f),
29244                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
29245                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
29246                 (ndr_print_function_t) ndr_print_spoolss_5f,
29247                 false,
29248         },
29249         { NULL, 0, NULL, NULL, NULL, false }
29250 };
29251
29252 static const char * const spoolss_endpoint_strings[] = {
29253         "ncacn_np:[\\pipe\\spoolss]",
29254 };
29255
29256 static const struct ndr_interface_string_array spoolss_endpoints = {
29257         .count  = 1,
29258         .names  = spoolss_endpoint_strings
29259 };
29260
29261 static const char * const spoolss_authservice_strings[] = {
29262         "host",
29263 };
29264
29265 static const struct ndr_interface_string_array spoolss_authservices = {
29266         .count  = 1,
29267         .names  = spoolss_authservice_strings
29268 };
29269
29270
29271 const struct ndr_interface_table ndr_table_spoolss = {
29272         .name           = "spoolss",
29273         .syntax_id      = {
29274                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
29275                 NDR_SPOOLSS_VERSION
29276         },
29277         .helpstring     = NDR_SPOOLSS_HELPSTRING,
29278         .num_calls      = 96,
29279         .calls          = spoolss_calls,
29280         .endpoints      = &spoolss_endpoints,
29281         .authservices   = &spoolss_authservices
29282 };
29283