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                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
  22         }
  23         if (ndr_flags & NDR_BUFFERS) {
  24         }
  25         return NDR_ERR_SUCCESS;
  26 }
  27
  28 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  29 {
  30         if (ndr_flags & NDR_SCALARS) {
  31                 NDR_CHECK(ndr_pull_align(ndr, 2));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  39                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  40                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
  41         }
  42         if (ndr_flags & NDR_BUFFERS) {
  43         }
  44         return NDR_ERR_SUCCESS;
  45 }
  46
  47 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  48 {
  49         ndr_print_struct(ndr, name, "spoolss_Time");
  50         ndr->depth++;
  51         ndr_print_uint16(ndr, "year", r->year);
  52         ndr_print_uint16(ndr, "month", r->month);
  53         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  54         ndr_print_uint16(ndr, "day", r->day);
  55         ndr_print_uint16(ndr, "hour", r->hour);
  56         ndr_print_uint16(ndr, "minute", r->minute);
  57         ndr_print_uint16(ndr, "second", r->second);
  58         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  59         ndr->depth--;
  60 }
  61
  62 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  63 {
  64         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  65 }
  66
  67 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  68 {
  69         if (ndr_flags & NDR_SCALARS) {
  70                 NDR_CHECK(ndr_push_align(ndr, 5));
  71                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  72                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  73                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
  74         }
  75         if (ndr_flags & NDR_BUFFERS) {
  76                 if (r->time) {
  77                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  78                 }
  79         }
  80         return NDR_ERR_SUCCESS;
  81 }
  82
  83 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  84 {
  85         uint32_t _ptr_time;
  86         TALLOC_CTX *_mem_save_time_0;
  87         if (ndr_flags & NDR_SCALARS) {
  88                 NDR_CHECK(ndr_pull_align(ndr, 5));
  89                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  90                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  91                 if (_ptr_time) {
  92                         NDR_PULL_ALLOC(ndr, r->time);
  93                 } else {
  94                         r->time = NULL;
  95                 }
  96                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
  97         }
  98         if (ndr_flags & NDR_BUFFERS) {
  99                 if (r->time) {
 100                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
 101                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
 102                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
 103                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 104                 }
 105         }
 106         return NDR_ERR_SUCCESS;
 107 }
 108
 109 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 110 {
 111         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 112         ndr->depth++;
 113         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 114         ndr_print_ptr(ndr, "time", r->time);
 115         ndr->depth++;
 116         if (r->time) {
 117                 ndr_print_spoolss_Time(ndr, "time", r->time);
 118         }
 119         ndr->depth--;
 120         ndr->depth--;
 121 }
 122
 123 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 124 {
 125         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 126         return NDR_ERR_SUCCESS;
 127 }
 128
 129 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 130 {
 131         uint16_t v;
 132         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 133         *r = v;
 134         return NDR_ERR_SUCCESS;
 135 }
 136
 137 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 138 {
 139         const char *val = NULL;
 140
 141         switch (r) {
 142                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 143                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 144                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 145         }
 146         ndr_print_enum(ndr, name, "ENUM", val, r);
 147 }
 148
 149 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 150 {
 151         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 152         return NDR_ERR_SUCCESS;
 153 }
 154
 155 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 156 {
 157         uint32_t v;
 158         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 159         *r = v;
 160         return NDR_ERR_SUCCESS;
 161 }
 162
 163 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 164 {
 165         const char *val = NULL;
 166
 167         switch (r) {
 168                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 169                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 170                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 171                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 172                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 173         }
 174         ndr_print_enum(ndr, name, "ENUM", val, r);
 175 }
 176
 177 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 178 {
 179         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 180         return NDR_ERR_SUCCESS;
 181 }
 182
 183 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 184 {
 185         uint32_t v;
 186         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 187         *r = v;
 188         return NDR_ERR_SUCCESS;
 189 }
 190
 191 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 192 {
 193         const char *val = NULL;
 194
 195         switch (r) {
 196                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 197                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 198                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 199         }
 200         ndr_print_enum(ndr, name, "ENUM", val, r);
 201 }
 202
 203 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 204 {
 205         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 206         return NDR_ERR_SUCCESS;
 207 }
 208
 209 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 210 {
 211         uint32_t v;
 212         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 213         *r = v;
 214         return NDR_ERR_SUCCESS;
 215 }
 216
 217 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 218 {
 219         const char *val = NULL;
 220
 221         switch (r) {
 222                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 223                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 224                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 225                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 226                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 227         }
 228         ndr_print_enum(ndr, name, "ENUM", val, r);
 229 }
 230
 231 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 232 {
 233         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 234         return NDR_ERR_SUCCESS;
 235 }
 236
 237 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 238 {
 239         uint32_t v;
 240         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 241         *r = v;
 242         return NDR_ERR_SUCCESS;
 243 }
 244
 245 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 246 {
 247         ndr_print_uint32(ndr, name, r);
 248         ndr->depth++;
 249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 259         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 270         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 271         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 272         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 273         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 274         ndr->depth--;
 275 }
 276
 277 static enum ndr_err_code ndr_push_spoolss_JobStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 278 {
 279         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 280         return NDR_ERR_SUCCESS;
 281 }
 282
 283 static enum ndr_err_code ndr_pull_spoolss_JobStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 284 {
 285         uint32_t v;
 286         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 287         *r = v;
 288         return NDR_ERR_SUCCESS;
 289 }
 290
 291 _PUBLIC_ void ndr_print_spoolss_JobStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 292 {
 293         ndr_print_uint32(ndr, name, r);
 294         ndr->depth++;
 295         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAUSED", JOB_STATUS_PAUSED, r);
 296         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_ERROR", JOB_STATUS_ERROR, r);
 297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETING", JOB_STATUS_DELETING, r);
 298         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_SPOOLING", JOB_STATUS_SPOOLING, r);
 299         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTING", JOB_STATUS_PRINTING, r);
 300         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_OFFLINE", JOB_STATUS_OFFLINE, r);
 301         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAPEROUT", JOB_STATUS_PAPEROUT, r);
 302         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTED", JOB_STATUS_PRINTED, r);
 303         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETED", JOB_STATUS_DELETED, r);
 304         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_BLOCKED_DEVQ", JOB_STATUS_BLOCKED_DEVQ, r);
 305         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_USER_INTERVENTION", JOB_STATUS_USER_INTERVENTION, r);
 306         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_RESTART", JOB_STATUS_RESTART, r);
 307         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_COMPLETE", JOB_STATUS_COMPLETE, r);
 308         ndr->depth--;
 309 }
 310
 311 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 312 {
 313         if (ndr_flags & NDR_SCALARS) {
 314                 NDR_CHECK(ndr_push_align(ndr, 5));
 315                 {
 316                         uint32_t _flags_save_string = ndr->flags;
 317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 318                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 319                         ndr->flags = _flags_save_string;
 320                 }
 321                 {
 322                         uint32_t _flags_save_string = ndr->flags;
 323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 324                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 325                         ndr->flags = _flags_save_string;
 326                 }
 327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 330                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 340                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->job_error));
 341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 342                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 345                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 346                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
 347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 349                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 350                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 354                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 355         }
 356         if (ndr_flags & NDR_BUFFERS) {
 357                 {
 358                         uint32_t _flags_save_string = ndr->flags;
 359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 360                         if (r->printername) {
 361                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
 362                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 363                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
 364                         }
 365                         ndr->flags = _flags_save_string;
 366                 }
 367                 {
 368                         uint32_t _flags_save_string = ndr->flags;
 369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 370                         if (r->servername) {
 371                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->servername));
 372                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 373                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->servername));
 374                         }
 375                         ndr->flags = _flags_save_string;
 376                 }
 377         }
 378         return NDR_ERR_SUCCESS;
 379 }
 380
 381 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 382 {
 383         uint32_t _ptr_printername;
 384         TALLOC_CTX *_mem_save_printername_0;
 385         uint32_t _ptr_servername;
 386         TALLOC_CTX *_mem_save_servername_0;
 387         if (ndr_flags & NDR_SCALARS) {
 388                 NDR_CHECK(ndr_pull_align(ndr, 5));
 389                 {
 390                         uint32_t _flags_save_string = ndr->flags;
 391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 392                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 393                         if (_ptr_printername) {
 394                                 NDR_PULL_ALLOC(ndr, r->printername);
 395                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 396                         } else {
 397                                 r->printername = NULL;
 398                         }
 399                         ndr->flags = _flags_save_string;
 400                 }
 401                 {
 402                         uint32_t _flags_save_string = ndr->flags;
 403                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 404                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 405                         if (_ptr_servername) {
 406                                 NDR_PULL_ALLOC(ndr, r->servername);
 407                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 408                         } else {
 409                                 r->servername = NULL;
 410                         }
 411                         ndr->flags = _flags_save_string;
 412                 }
 413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 416                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 424                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 426                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 428                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 429                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 431                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 432                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 434                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 435                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 436                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 438                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 440                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 441         }
 442         if (ndr_flags & NDR_BUFFERS) {
 443                 {
 444                         uint32_t _flags_save_string = ndr->flags;
 445                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 446                         if (r->printername) {
 447                                 uint32_t _relative_save_offset;
 448                                 _relative_save_offset = ndr->offset;
 449                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 450                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 451                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 452                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 453                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 454                                 if (ndr->offset > ndr->relative_highest_offset) {
 455                                         ndr->relative_highest_offset = ndr->offset;
 456                                 }
 457                                 ndr->offset = _relative_save_offset;
 458                         }
 459                         ndr->flags = _flags_save_string;
 460                 }
 461                 {
 462                         uint32_t _flags_save_string = ndr->flags;
 463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 464                         if (r->servername) {
 465                                 uint32_t _relative_save_offset;
 466                                 _relative_save_offset = ndr->offset;
 467                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 468                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 469                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 470                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 471                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 472                                 if (ndr->offset > ndr->relative_highest_offset) {
 473                                         ndr->relative_highest_offset = ndr->offset;
 474                                 }
 475                                 ndr->offset = _relative_save_offset;
 476                         }
 477                         ndr->flags = _flags_save_string;
 478                 }
 479         }
 480         return NDR_ERR_SUCCESS;
 481 }
 482
 483 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 484 {
 485         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 486         ndr->depth++;
 487         ndr_print_ptr(ndr, "printername", r->printername);
 488         ndr->depth++;
 489         if (r->printername) {
 490                 ndr_print_string(ndr, "printername", r->printername);
 491         }
 492         ndr->depth--;
 493         ndr_print_ptr(ndr, "servername", r->servername);
 494         ndr->depth++;
 495         if (r->servername) {
 496                 ndr_print_string(ndr, "servername", r->servername);
 497         }
 498         ndr->depth--;
 499         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 500         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 501         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 502         ndr_print_spoolss_Time(ndr, "time", &r->time);
 503         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 504         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 505         ndr_print_uint32(ndr, "version", r->version);
 506         ndr_print_uint32(ndr, "free_build", r->free_build);
 507         ndr_print_uint32(ndr, "spooling", r->spooling);
 508         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 509         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 510         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 511         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 512         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 513         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 514         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 515         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 516         ndr_print_uint32(ndr, "change_id", r->change_id);
 517         ndr_print_WERROR(ndr, "last_error", r->last_error);
 518         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 519         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 520         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 521         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 522         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 523         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 524         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 525         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 526         ndr->depth--;
 527 }
 528
 529 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo0(const struct spoolss_PrinterInfo0 *r, struct smb_iconv_convenience *ic, int flags)
 530 {
 531         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo0, ic);
 532 }
 533
 534 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 535 {
 536         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 537         return NDR_ERR_SUCCESS;
 538 }
 539
 540 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 541 {
 542         uint32_t v;
 543         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 544         *r = v;
 545         return NDR_ERR_SUCCESS;
 546 }
 547
 548 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 549 {
 550         ndr_print_uint32(ndr, name, r);
 551         ndr->depth++;
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 561         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 562         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 563         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 564         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 565         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 566         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 567         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 568         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 569         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 570         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 571         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 572         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 573         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 574         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 575         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 576         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 577         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 578         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 579         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 580         ndr->depth--;
 581 }
 582
 583 static enum ndr_err_code ndr_push_spoolss_DeviceModeSpecVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion r)
 584 {
 585         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 586         return NDR_ERR_SUCCESS;
 587 }
 588
 589 static enum ndr_err_code ndr_pull_spoolss_DeviceModeSpecVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion *r)
 590 {
 591         uint16_t v;
 592         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 593         *r = v;
 594         return NDR_ERR_SUCCESS;
 595 }
 596
 597 _PUBLIC_ void ndr_print_spoolss_DeviceModeSpecVersion(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeSpecVersion r)
 598 {
 599         const char *val = NULL;
 600
 601         switch (r) {
 602                 case DMSPEC_NT3: val = "DMSPEC_NT3"; break;
 603                 case DMSPEC_WIN95_98_ME: val = "DMSPEC_WIN95_98_ME"; break;
 604                 case DMSPEC_NT4_AND_ABOVE: val = "DMSPEC_NT4_AND_ABOVE"; break;
 605         }
 606         ndr_print_enum(ndr, name, "ENUM", val, r);
 607 }
 608
 609 static enum ndr_err_code ndr_push_spoolss_DeviceModeOrientation(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation r)
 610 {
 611         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 612         return NDR_ERR_SUCCESS;
 613 }
 614
 615 static enum ndr_err_code ndr_pull_spoolss_DeviceModeOrientation(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation *r)
 616 {
 617         uint16_t v;
 618         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 619         *r = v;
 620         return NDR_ERR_SUCCESS;
 621 }
 622
 623 _PUBLIC_ void ndr_print_spoolss_DeviceModeOrientation(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeOrientation r)
 624 {
 625         const char *val = NULL;
 626
 627         switch (r) {
 628                 case DMORIENT_PORTRAIT: val = "DMORIENT_PORTRAIT"; break;
 629                 case DMORIENT_LANDSCAPE: val = "DMORIENT_LANDSCAPE"; break;
 630         }
 631         ndr_print_enum(ndr, name, "ENUM", val, r);
 632 }
 633
 634 static enum ndr_err_code ndr_push_spoolss_DeviceModePaperSize(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize r)
 635 {
 636         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 637         return NDR_ERR_SUCCESS;
 638 }
 639
 640 static enum ndr_err_code ndr_pull_spoolss_DeviceModePaperSize(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize *r)
 641 {
 642         uint16_t v;
 643         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 644         *r = v;
 645         return NDR_ERR_SUCCESS;
 646 }
 647
 648 _PUBLIC_ void ndr_print_spoolss_DeviceModePaperSize(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePaperSize r)
 649 {
 650         const char *val = NULL;
 651
 652         switch (r) {
 653                 case DMPAPER_LETTER: val = "DMPAPER_LETTER"; break;
 654                 case DMPAPER_LETTERSMALL: val = "DMPAPER_LETTERSMALL"; break;
 655                 case DMPAPER_TABLOID: val = "DMPAPER_TABLOID"; break;
 656                 case DMPAPER_LEDGER: val = "DMPAPER_LEDGER"; break;
 657                 case DMPAPER_LEGAL: val = "DMPAPER_LEGAL"; break;
 658                 case DMPAPER_STATEMENT: val = "DMPAPER_STATEMENT"; break;
 659                 case DMPAPER_EXECUTIVE: val = "DMPAPER_EXECUTIVE"; break;
 660                 case DMPAPER_A3: val = "DMPAPER_A3"; break;
 661                 case DMPAPER_A4: val = "DMPAPER_A4"; break;
 662                 case DMPAPER_A4SMALL: val = "DMPAPER_A4SMALL"; break;
 663                 case DMPAPER_A5: val = "DMPAPER_A5"; break;
 664                 case DMPAPER_B4: val = "DMPAPER_B4"; break;
 665                 case DMPAPER_B5: val = "DMPAPER_B5"; break;
 666                 case DMPAPER_FOLIO: val = "DMPAPER_FOLIO"; break;
 667                 case DMPAPER_QUARTO: val = "DMPAPER_QUARTO"; break;
 668                 case DMPAPER_10X14: val = "DMPAPER_10X14"; break;
 669                 case DMPAPER_11X17: val = "DMPAPER_11X17"; break;
 670                 case DMPAPER_NOTE: val = "DMPAPER_NOTE"; break;
 671                 case DMPAPER_ENV_9: val = "DMPAPER_ENV_9"; break;
 672                 case DMPAPER_ENV_10: val = "DMPAPER_ENV_10"; break;
 673                 case DMPAPER_ENV_11: val = "DMPAPER_ENV_11"; break;
 674                 case DMPAPER_ENV_12: val = "DMPAPER_ENV_12"; break;
 675                 case DMPAPER_ENV_14: val = "DMPAPER_ENV_14"; break;
 676                 case DMPAPER_CSHEET: val = "DMPAPER_CSHEET"; break;
 677                 case DMPAPER_DSHEET: val = "DMPAPER_DSHEET"; break;
 678                 case DMPAPER_ESHEET: val = "DMPAPER_ESHEET"; break;
 679                 case DMPAPER_ENV_DL: val = "DMPAPER_ENV_DL"; break;
 680                 case DMPAPER_ENV_C5: val = "DMPAPER_ENV_C5"; break;
 681                 case DMPAPER_ENV_C3: val = "DMPAPER_ENV_C3"; break;
 682                 case DMPAPER_ENV_C4: val = "DMPAPER_ENV_C4"; break;
 683                 case DMPAPER_ENV_C6: val = "DMPAPER_ENV_C6"; break;
 684                 case DMPAPER_ENV_C65: val = "DMPAPER_ENV_C65"; break;
 685                 case DMPAPER_ENV_B4: val = "DMPAPER_ENV_B4"; break;
 686                 case DMPAPER_ENV_B5: val = "DMPAPER_ENV_B5"; break;
 687                 case DMPAPER_ENV_B6: val = "DMPAPER_ENV_B6"; break;
 688                 case DMPAPER_ENV_ITALY: val = "DMPAPER_ENV_ITALY"; break;
 689                 case DMPAPER_ENV_MONARCH: val = "DMPAPER_ENV_MONARCH"; break;
 690                 case DMPAPER_ENV_PERSONAL: val = "DMPAPER_ENV_PERSONAL"; break;
 691                 case DMPAPER_FANFOLD_US: val = "DMPAPER_FANFOLD_US"; break;
 692                 case DMPAPER_FANFOLD_STD_GERMAN: val = "DMPAPER_FANFOLD_STD_GERMAN"; break;
 693                 case DMPAPER_FANFOLD_LGL_GERMAN: val = "DMPAPER_FANFOLD_LGL_GERMAN"; break;
 694                 case DMPAPER_DBL_JAPANESE_POSTCARD: val = "DMPAPER_DBL_JAPANESE_POSTCARD"; break;
 695                 case DMPAPER_A6: val = "DMPAPER_A6"; break;
 696                 case DMPAPER_JENV_KAKU2: val = "DMPAPER_JENV_KAKU2"; break;
 697                 case DMPAPER_JENV_KAKU3: val = "DMPAPER_JENV_KAKU3"; break;
 698                 case DMPAPER_JENV_CHOU3: val = "DMPAPER_JENV_CHOU3"; break;
 699                 case DMPAPER_JENV_CHOU4: val = "DMPAPER_JENV_CHOU4"; break;
 700                 case DMPAPER_LETTER_ROTATED: val = "DMPAPER_LETTER_ROTATED"; break;
 701                 case DMPAPER_A3_ROTATED: val = "DMPAPER_A3_ROTATED"; break;
 702                 case DMPAPER_A4_ROTATED: val = "DMPAPER_A4_ROTATED"; break;
 703                 case DMPAPER_A5_ROTATED: val = "DMPAPER_A5_ROTATED"; break;
 704                 case DMPAPER_B4_JIS_ROTATED: val = "DMPAPER_B4_JIS_ROTATED"; break;
 705                 case DMPAPER_B5_JIS_ROTATED: val = "DMPAPER_B5_JIS_ROTATED"; break;
 706                 case DMPAPER_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_JAPANESE_POSTCARD_ROTATED"; break;
 707                 case DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED"; break;
 708                 case DMPAPER_A6_ROTATED: val = "DMPAPER_A6_ROTATED"; break;
 709                 case DMPAPER_JENV_KAKU2_ROTATED: val = "DMPAPER_JENV_KAKU2_ROTATED"; break;
 710                 case DMPAPER_JENV_KAKU3_ROTATED: val = "DMPAPER_JENV_KAKU3_ROTATED"; break;
 711                 case DMPAPER_JENV_CHOU3_ROTATED: val = "DMPAPER_JENV_CHOU3_ROTATED"; break;
 712                 case DMPAPER_JENV_CHOU4_ROTATED: val = "DMPAPER_JENV_CHOU4_ROTATED"; break;
 713                 case DMPAPER_B6_JIS: val = "DMPAPER_B6_JIS"; break;
 714                 case DMPAPER_B6_JIS_ROTATED: val = "DMPAPER_B6_JIS_ROTATED"; break;
 715                 case DMPAPER_12X11: val = "DMPAPER_12X11"; break;
 716                 case DMPAPER_JENV_YOU4: val = "DMPAPER_JENV_YOU4"; break;
 717                 case DMPAPER_JENV_YOU4_ROTATED: val = "DMPAPER_JENV_YOU4_ROTATED"; break;
 718                 case DMPAPER_P16K: val = "DMPAPER_P16K"; break;
 719                 case DMPAPER_P32K: val = "DMPAPER_P32K"; break;
 720                 case DMPAPER_P32KBIG: val = "DMPAPER_P32KBIG"; break;
 721                 case DMPAPER_PENV_1: val = "DMPAPER_PENV_1"; break;
 722                 case DMPAPER_PENV_2: val = "DMPAPER_PENV_2"; break;
 723                 case DMPAPER_PENV_3: val = "DMPAPER_PENV_3"; break;
 724                 case DMPAPER_PENV_4: val = "DMPAPER_PENV_4"; break;
 725                 case DMPAPER_PENV_5: val = "DMPAPER_PENV_5"; break;
 726                 case DMPAPER_PENV_6: val = "DMPAPER_PENV_6"; break;
 727                 case DMPAPER_PENV_7: val = "DMPAPER_PENV_7"; break;
 728                 case DMPAPER_PENV_8: val = "DMPAPER_PENV_8"; break;
 729                 case DMPAPER_PENV_9: val = "DMPAPER_PENV_9"; break;
 730                 case DMPAPER_PENV_10: val = "DMPAPER_PENV_10"; break;
 731                 case DMPAPER_P16K_ROTATED: val = "DMPAPER_P16K_ROTATED"; break;
 732                 case DMPAPER_P32K_ROTATED: val = "DMPAPER_P32K_ROTATED"; break;
 733                 case DMPAPER_P32KBIG_ROTATED: val = "DMPAPER_P32KBIG_ROTATED"; break;
 734                 case DMPAPER_PENV_1_ROTATED: val = "DMPAPER_PENV_1_ROTATED"; break;
 735                 case DMPAPER_PENV_2_ROTATED: val = "DMPAPER_PENV_2_ROTATED"; break;
 736                 case DMPAPER_PENV_3_ROTATED: val = "DMPAPER_PENV_3_ROTATED"; break;
 737                 case DMPAPER_PENV_4_ROTATED: val = "DMPAPER_PENV_4_ROTATED"; break;
 738                 case DMPAPER_PENV_5_ROTATED: val = "DMPAPER_PENV_5_ROTATED"; break;
 739                 case DMPAPER_PENV_6_ROTATED: val = "DMPAPER_PENV_6_ROTATED"; break;
 740                 case DMPAPER_PENV_7_ROTATED: val = "DMPAPER_PENV_7_ROTATED"; break;
 741                 case DMPAPER_PENV_8_ROTATED: val = "DMPAPER_PENV_8_ROTATED"; break;
 742                 case DMPAPER_PENV_9_ROTATED: val = "DMPAPER_PENV_9_ROTATED"; break;
 743                 case DMPAPER_PENV_10_ROTATED: val = "DMPAPER_PENV_10_ROTATED"; break;
 744         }
 745         ndr_print_enum(ndr, name, "ENUM", val, r);
 746 }
 747
 748 static enum ndr_err_code ndr_push_spoolss_DeviceModeDefaultSource(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource r)
 749 {
 750         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 751         return NDR_ERR_SUCCESS;
 752 }
 753
 754 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDefaultSource(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource *r)
 755 {
 756         uint16_t v;
 757         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 758         *r = v;
 759         return NDR_ERR_SUCCESS;
 760 }
 761
 762 _PUBLIC_ void ndr_print_spoolss_DeviceModeDefaultSource(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDefaultSource r)
 763 {
 764         const char *val = NULL;
 765
 766         switch (r) {
 767                 case DMBIN_UPPER: val = "DMBIN_UPPER"; break;
 768                 case DMBIN_LOWER: val = "DMBIN_LOWER"; break;
 769                 case DMBIN_MIDDLE: val = "DMBIN_MIDDLE"; break;
 770                 case DMBIN_MANUAL: val = "DMBIN_MANUAL"; break;
 771                 case DMBIN_ENVELOPE: val = "DMBIN_ENVELOPE"; break;
 772                 case DMBIN_ENVMANUAL: val = "DMBIN_ENVMANUAL"; break;
 773                 case DMBIN_AUTO: val = "DMBIN_AUTO"; break;
 774                 case DMBIN_TRACTOR: val = "DMBIN_TRACTOR"; break;
 775                 case DMBIN_SMALLFMT: val = "DMBIN_SMALLFMT"; break;
 776                 case DMBIN_LARGEFMT: val = "DMBIN_LARGEFMT"; break;
 777                 case DMBIN_LARGECAPACITY: val = "DMBIN_LARGECAPACITY"; break;
 778                 case DMBIN_CASSETTE: val = "DMBIN_CASSETTE"; break;
 779                 case DMBIN_FORMSOURCE: val = "DMBIN_FORMSOURCE"; break;
 780         }
 781         ndr_print_enum(ndr, name, "ENUM", val, r);
 782 }
 783
 784 static enum ndr_err_code ndr_push_spoolss_DeviceModePrintQuality(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality r)
 785 {
 786         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 787         return NDR_ERR_SUCCESS;
 788 }
 789
 790 static enum ndr_err_code ndr_pull_spoolss_DeviceModePrintQuality(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality *r)
 791 {
 792         uint16_t v;
 793         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 794         *r = v;
 795         return NDR_ERR_SUCCESS;
 796 }
 797
 798 _PUBLIC_ void ndr_print_spoolss_DeviceModePrintQuality(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePrintQuality r)
 799 {
 800         const char *val = NULL;
 801
 802         switch (r) {
 803                 case DMRES_HIGH: val = "DMRES_HIGH"; break;
 804                 case DMRES_MEDIUM: val = "DMRES_MEDIUM"; break;
 805                 case DMRES_LOW: val = "DMRES_LOW"; break;
 806                 case DMRES_DRAFT: val = "DMRES_DRAFT"; break;
 807         }
 808         ndr_print_enum(ndr, name, "ENUM", val, r);
 809 }
 810
 811 static enum ndr_err_code ndr_push_spoolss_DeviceModeColor(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeColor r)
 812 {
 813         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 814         return NDR_ERR_SUCCESS;
 815 }
 816
 817 static enum ndr_err_code ndr_pull_spoolss_DeviceModeColor(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeColor *r)
 818 {
 819         uint16_t v;
 820         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 821         *r = v;
 822         return NDR_ERR_SUCCESS;
 823 }
 824
 825 _PUBLIC_ void ndr_print_spoolss_DeviceModeColor(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeColor r)
 826 {
 827         const char *val = NULL;
 828
 829         switch (r) {
 830                 case DMRES_MONOCHROME: val = "DMRES_MONOCHROME"; break;
 831                 case DMRES_COLOR: val = "DMRES_COLOR"; break;
 832         }
 833         ndr_print_enum(ndr, name, "ENUM", val, r);
 834 }
 835
 836 static enum ndr_err_code ndr_push_spoolss_DeviceModeDuplex(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex r)
 837 {
 838         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 839         return NDR_ERR_SUCCESS;
 840 }
 841
 842 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDuplex(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex *r)
 843 {
 844         uint16_t v;
 845         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 846         *r = v;
 847         return NDR_ERR_SUCCESS;
 848 }
 849
 850 _PUBLIC_ void ndr_print_spoolss_DeviceModeDuplex(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDuplex r)
 851 {
 852         const char *val = NULL;
 853
 854         switch (r) {
 855                 case DMDUP_SIMPLEX: val = "DMDUP_SIMPLEX"; break;
 856                 case DMDUP_VERTICAL: val = "DMDUP_VERTICAL"; break;
 857                 case DMDUP_HORIZONTAL: val = "DMDUP_HORIZONTAL"; break;
 858         }
 859         ndr_print_enum(ndr, name, "ENUM", val, r);
 860 }
 861
 862 static enum ndr_err_code ndr_push_spoolss_DeviceModeTTOption(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption r)
 863 {
 864         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 865         return NDR_ERR_SUCCESS;
 866 }
 867
 868 static enum ndr_err_code ndr_pull_spoolss_DeviceModeTTOption(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption *r)
 869 {
 870         uint16_t v;
 871         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 872         *r = v;
 873         return NDR_ERR_SUCCESS;
 874 }
 875
 876 _PUBLIC_ void ndr_print_spoolss_DeviceModeTTOption(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeTTOption r)
 877 {
 878         const char *val = NULL;
 879
 880         switch (r) {
 881                 case DMTT_BITMAP: val = "DMTT_BITMAP"; break;
 882                 case DMTT_DOWNLOAD: val = "DMTT_DOWNLOAD"; break;
 883                 case DMTT_SUBDEV: val = "DMTT_SUBDEV"; break;
 884                 case DMTT_DOWNLOAD_OUTLINE: val = "DMTT_DOWNLOAD_OUTLINE"; break;
 885         }
 886         ndr_print_enum(ndr, name, "ENUM", val, r);
 887 }
 888
 889 static enum ndr_err_code ndr_push_spoolss_DeviceModeCollate(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeCollate r)
 890 {
 891         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 892         return NDR_ERR_SUCCESS;
 893 }
 894
 895 static enum ndr_err_code ndr_pull_spoolss_DeviceModeCollate(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeCollate *r)
 896 {
 897         uint16_t v;
 898         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 899         *r = v;
 900         return NDR_ERR_SUCCESS;
 901 }
 902
 903 _PUBLIC_ void ndr_print_spoolss_DeviceModeCollate(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeCollate r)
 904 {
 905         const char *val = NULL;
 906
 907         switch (r) {
 908                 case DMCOLLATE_FALSE: val = "DMCOLLATE_FALSE"; break;
 909                 case DMCOLLATE_TRUE: val = "DMCOLLATE_TRUE"; break;
 910         }
 911         ndr_print_enum(ndr, name, "ENUM", val, r);
 912 }
 913
 914 static enum ndr_err_code ndr_push_spoolss_DeviceModeNUp(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeNUp r)
 915 {
 916         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 917         return NDR_ERR_SUCCESS;
 918 }
 919
 920 static enum ndr_err_code ndr_pull_spoolss_DeviceModeNUp(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeNUp *r)
 921 {
 922         uint32_t v;
 923         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 924         *r = v;
 925         return NDR_ERR_SUCCESS;
 926 }
 927
 928 _PUBLIC_ void ndr_print_spoolss_DeviceModeNUp(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeNUp r)
 929 {
 930         const char *val = NULL;
 931
 932         switch (r) {
 933                 case DMNUP_SYSTEM: val = "DMNUP_SYSTEM"; break;
 934                 case DMNUP_ONEUP: val = "DMNUP_ONEUP"; break;
 935         }
 936         ndr_print_enum(ndr, name, "ENUM", val, r);
 937 }
 938
 939 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMMethod(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod r)
 940 {
 941         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 942         return NDR_ERR_SUCCESS;
 943 }
 944
 945 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMMethod(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod *r)
 946 {
 947         uint32_t v;
 948         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 949         *r = v;
 950         return NDR_ERR_SUCCESS;
 951 }
 952
 953 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMMethod(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMMethod r)
 954 {
 955         const char *val = NULL;
 956
 957         switch (r) {
 958                 case DMICMMETHOD_NONE: val = "DMICMMETHOD_NONE"; break;
 959                 case DMICMMETHOD_SYSTEM: val = "DMICMMETHOD_SYSTEM"; break;
 960                 case DMICMMETHOD_DRIVER: val = "DMICMMETHOD_DRIVER"; break;
 961                 case DMICMMETHOD_DEVICE: val = "DMICMMETHOD_DEVICE"; break;
 962         }
 963         ndr_print_enum(ndr, name, "ENUM", val, r);
 964 }
 965
 966 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMIntent(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent r)
 967 {
 968         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 969         return NDR_ERR_SUCCESS;
 970 }
 971
 972 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMIntent(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent *r)
 973 {
 974         uint32_t v;
 975         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 976         *r = v;
 977         return NDR_ERR_SUCCESS;
 978 }
 979
 980 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMIntent(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMIntent r)
 981 {
 982         const char *val = NULL;
 983
 984         switch (r) {
 985                 case DMICM_SATURATE: val = "DMICM_SATURATE"; break;
 986                 case DMICM_CONTRAST: val = "DMICM_CONTRAST"; break;
 987                 case DMICM_COLORIMETRIC: val = "DMICM_COLORIMETRIC"; break;
 988                 case DMICM_ABS_COLORIMETRIC: val = "DMICM_ABS_COLORIMETRIC"; break;
 989         }
 990         ndr_print_enum(ndr, name, "ENUM", val, r);
 991 }
 992
 993 static enum ndr_err_code ndr_push_spoolss_DeviceModeMediaType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType r)
 994 {
 995         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 996         return NDR_ERR_SUCCESS;
 997 }
 998
 999 static enum ndr_err_code ndr_pull_spoolss_DeviceModeMediaType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType *r)
1000 {
1001         uint32_t v;
1002         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1003         *r = v;
1004         return NDR_ERR_SUCCESS;
1005 }
1006
1007 _PUBLIC_ void ndr_print_spoolss_DeviceModeMediaType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeMediaType r)
1008 {
1009         const char *val = NULL;
1010
1011         switch (r) {
1012                 case DMMEDIA_STANDARD: val = "DMMEDIA_STANDARD"; break;
1013                 case DMMEDIA_TRANSPARENCY: val = "DMMEDIA_TRANSPARENCY"; break;
1014                 case DMMEDIA_GLOSSY: val = "DMMEDIA_GLOSSY"; break;
1015         }
1016         ndr_print_enum(ndr, name, "ENUM", val, r);
1017 }
1018
1019 static enum ndr_err_code ndr_push_spoolss_DeviceModeDitherType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType r)
1020 {
1021         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1022         return NDR_ERR_SUCCESS;
1023 }
1024
1025 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDitherType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType *r)
1026 {
1027         uint32_t v;
1028         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1029         *r = v;
1030         return NDR_ERR_SUCCESS;
1031 }
1032
1033 _PUBLIC_ void ndr_print_spoolss_DeviceModeDitherType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDitherType r)
1034 {
1035         const char *val = NULL;
1036
1037         switch (r) {
1038                 case DMDITHER_NONE: val = "DMDITHER_NONE"; break;
1039                 case DMDITHER_COARSE: val = "DMDITHER_COARSE"; break;
1040                 case DMDITHER_FINE: val = "DMDITHER_FINE"; break;
1041                 case DMDITHER_LINEART: val = "DMDITHER_LINEART"; break;
1042                 case DMDITHER_ERRORDIFFUSION: val = "DMDITHER_ERRORDIFFUSION"; break;
1043                 case DMDITHER_RESERVED6: val = "DMDITHER_RESERVED6"; break;
1044                 case DMDITHER_RESERVED7: val = "DMDITHER_RESERVED7"; break;
1045                 case DMDITHER_RESERVED8: val = "DMDITHER_RESERVED8"; break;
1046                 case DMDITHER_RESERVED9: val = "DMDITHER_RESERVED9"; break;
1047                 case DMDITHER_GRAYSCALE: val = "DMDITHER_GRAYSCALE"; break;
1048         }
1049         ndr_print_enum(ndr, name, "ENUM", val, r);
1050 }
1051
1052 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
1053 {
1054         if (ndr_flags & NDR_SCALARS) {
1055                 NDR_CHECK(ndr_push_align(ndr, 4));
1056                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1057                 NDR_CHECK(ndr_push_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, r->specversion));
1058                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
1059                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
1060                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
1061                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
1062                 NDR_CHECK(ndr_push_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, r->orientation));
1063                 NDR_CHECK(ndr_push_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, r->papersize));
1064                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
1065                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
1066                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
1067                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
1068                 NDR_CHECK(ndr_push_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, r->defaultsource));
1069                 NDR_CHECK(ndr_push_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, r->printquality));
1070                 NDR_CHECK(ndr_push_spoolss_DeviceModeColor(ndr, NDR_SCALARS, r->color));
1071                 NDR_CHECK(ndr_push_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, r->duplex));
1072                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
1073                 NDR_CHECK(ndr_push_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, r->ttoption));
1074                 NDR_CHECK(ndr_push_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, r->collate));
1075                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1076                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
1077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
1078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
1079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
1080                 NDR_CHECK(ndr_push_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, r->displayflags));
1081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
1082                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, r->icmmethod));
1083                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, r->icmintent));
1084                 NDR_CHECK(ndr_push_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, r->mediatype));
1085                 NDR_CHECK(ndr_push_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, r->dithertype));
1086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
1087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
1088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
1089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
1090                 {
1091                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1092                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1093                         {
1094                                 struct ndr_push *_ndr_driverextra_data;
1095                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
1096                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
1097                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
1098                         }
1099                         ndr->flags = _flags_save_DATA_BLOB;
1100                 }
1101                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1102         }
1103         if (ndr_flags & NDR_BUFFERS) {
1104         }
1105         return NDR_ERR_SUCCESS;
1106 }
1107
1108 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
1109 {
1110         if (ndr_flags & NDR_SCALARS) {
1111                 NDR_CHECK(ndr_pull_align(ndr, 4));
1112                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1113                 NDR_CHECK(ndr_pull_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, &r->specversion));
1114                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
1115                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
1116                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
1117                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
1118                 NDR_CHECK(ndr_pull_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, &r->orientation));
1119                 NDR_CHECK(ndr_pull_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, &r->papersize));
1120                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
1121                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
1122                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
1123                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
1124                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, &r->defaultsource));
1125                 NDR_CHECK(ndr_pull_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, &r->printquality));
1126                 NDR_CHECK(ndr_pull_spoolss_DeviceModeColor(ndr, NDR_SCALARS, &r->color));
1127                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, &r->duplex));
1128                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
1129                 NDR_CHECK(ndr_pull_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, &r->ttoption));
1130                 NDR_CHECK(ndr_pull_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, &r->collate));
1131                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1132                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
1133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
1134                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
1135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
1136                 NDR_CHECK(ndr_pull_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, &r->displayflags));
1137                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
1138                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, &r->icmmethod));
1139                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, &r->icmintent));
1140                 NDR_CHECK(ndr_pull_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, &r->mediatype));
1141                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, &r->dithertype));
1142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
1145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
1146                 {
1147                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1148                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1149                         {
1150                                 struct ndr_pull *_ndr_driverextra_data;
1151                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
1152                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
1153                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
1154                         }
1155                         ndr->flags = _flags_save_DATA_BLOB;
1156                 }
1157                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1158         }
1159         if (ndr_flags & NDR_BUFFERS) {
1160         }
1161         return NDR_ERR_SUCCESS;
1162 }
1163
1164 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
1165 {
1166         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
1167         ndr->depth++;
1168         ndr_print_string(ndr, "devicename", r->devicename);
1169         ndr_print_spoolss_DeviceModeSpecVersion(ndr, "specversion", r->specversion);
1170         ndr_print_uint16(ndr, "driverversion", r->driverversion);
1171         ndr_print_uint16(ndr, "size", r->size);
1172         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
1173         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
1174         ndr_print_spoolss_DeviceModeOrientation(ndr, "orientation", r->orientation);
1175         ndr_print_spoolss_DeviceModePaperSize(ndr, "papersize", r->papersize);
1176         ndr_print_uint16(ndr, "paperlength", r->paperlength);
1177         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
1178         ndr_print_uint16(ndr, "scale", r->scale);
1179         ndr_print_uint16(ndr, "copies", r->copies);
1180         ndr_print_spoolss_DeviceModeDefaultSource(ndr, "defaultsource", r->defaultsource);
1181         ndr_print_spoolss_DeviceModePrintQuality(ndr, "printquality", r->printquality);
1182         ndr_print_spoolss_DeviceModeColor(ndr, "color", r->color);
1183         ndr_print_spoolss_DeviceModeDuplex(ndr, "duplex", r->duplex);
1184         ndr_print_uint16(ndr, "yresolution", r->yresolution);
1185         ndr_print_spoolss_DeviceModeTTOption(ndr, "ttoption", r->ttoption);
1186         ndr_print_spoolss_DeviceModeCollate(ndr, "collate", r->collate);
1187         ndr_print_string(ndr, "formname", r->formname);
1188         ndr_print_uint16(ndr, "logpixels", r->logpixels);
1189         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
1190         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
1191         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
1192         ndr_print_spoolss_DeviceModeNUp(ndr, "displayflags", r->displayflags);
1193         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
1194         ndr_print_spoolss_DeviceModeICMMethod(ndr, "icmmethod", r->icmmethod);
1195         ndr_print_spoolss_DeviceModeICMIntent(ndr, "icmintent", r->icmintent);
1196         ndr_print_spoolss_DeviceModeMediaType(ndr, "mediatype", r->mediatype);
1197         ndr_print_spoolss_DeviceModeDitherType(ndr, "dithertype", r->dithertype);
1198         ndr_print_uint32(ndr, "reserved1", r->reserved1);
1199         ndr_print_uint32(ndr, "reserved2", r->reserved2);
1200         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
1201         ndr_print_uint32(ndr, "panningheight", r->panningheight);
1202         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
1203         ndr->depth--;
1204 }
1205
1206 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
1207 {
1208         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
1209 }
1210
1211 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1212 {
1213         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1214         return NDR_ERR_SUCCESS;
1215 }
1216
1217 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1218 {
1219         uint32_t v;
1220         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1221         *r = v;
1222         return NDR_ERR_SUCCESS;
1223 }
1224
1225 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
1226 {
1227         ndr_print_uint32(ndr, name, r);
1228         ndr->depth++;
1229         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
1230         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
1231         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
1232         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
1233         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
1234         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
1235         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
1236         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
1237         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
1238         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
1239         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
1240         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
1241         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
1242         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
1243         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
1244         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
1245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
1246         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
1247         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
1248         ndr->depth--;
1249 }
1250
1251 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1252 {
1253         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1254         return NDR_ERR_SUCCESS;
1255 }
1256
1257 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1258 {
1259         uint32_t v;
1260         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1261         *r = v;
1262         return NDR_ERR_SUCCESS;
1263 }
1264
1265 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
1266 {
1267         ndr_print_uint32(ndr, name, r);
1268         ndr->depth++;
1269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
1270         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
1271         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
1272         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
1273         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
1274         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
1275         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
1276         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
1277         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
1278         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
1279         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
1280         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
1281         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
1282         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
1283         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
1284         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
1285         ndr->depth--;
1286 }
1287
1288 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
1289 {
1290         if (ndr_flags & NDR_SCALARS) {
1291                 NDR_CHECK(ndr_push_align(ndr, 5));
1292                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
1293                 {
1294                         uint32_t _flags_save_string = ndr->flags;
1295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1296                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
1297                         ndr->flags = _flags_save_string;
1298                 }
1299                 {
1300                         uint32_t _flags_save_string = ndr->flags;
1301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1302                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
1303                         ndr->flags = _flags_save_string;
1304                 }
1305                 {
1306                         uint32_t _flags_save_string = ndr->flags;
1307                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1308                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1309                         ndr->flags = _flags_save_string;
1310                 }
1311                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1312         }
1313         if (ndr_flags & NDR_BUFFERS) {
1314                 {
1315                         uint32_t _flags_save_string = ndr->flags;
1316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1317                         if (r->description) {
1318                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->description));
1319                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
1320                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->description));
1321                         }
1322                         ndr->flags = _flags_save_string;
1323                 }
1324                 {
1325                         uint32_t _flags_save_string = ndr->flags;
1326                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1327                         if (r->name) {
1328                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->name));
1329                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
1330                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->name));
1331                         }
1332                         ndr->flags = _flags_save_string;
1333                 }
1334                 {
1335                         uint32_t _flags_save_string = ndr->flags;
1336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1337                         if (r->comment) {
1338                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->comment));
1339                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1340                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->comment));
1341                         }
1342                         ndr->flags = _flags_save_string;
1343                 }
1344         }
1345         return NDR_ERR_SUCCESS;
1346 }
1347
1348 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
1349 {
1350         uint32_t _ptr_description;
1351         TALLOC_CTX *_mem_save_description_0;
1352         uint32_t _ptr_name;
1353         TALLOC_CTX *_mem_save_name_0;
1354         uint32_t _ptr_comment;
1355         TALLOC_CTX *_mem_save_comment_0;
1356         if (ndr_flags & NDR_SCALARS) {
1357                 NDR_CHECK(ndr_pull_align(ndr, 5));
1358                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
1359                 {
1360                         uint32_t _flags_save_string = ndr->flags;
1361                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1362                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
1363                         if (_ptr_description) {
1364                                 NDR_PULL_ALLOC(ndr, r->description);
1365                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
1366                         } else {
1367                                 r->description = NULL;
1368                         }
1369                         ndr->flags = _flags_save_string;
1370                 }
1371                 {
1372                         uint32_t _flags_save_string = ndr->flags;
1373                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1374                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
1375                         if (_ptr_name) {
1376                                 NDR_PULL_ALLOC(ndr, r->name);
1377                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
1378                         } else {
1379                                 r->name = NULL;
1380                         }
1381                         ndr->flags = _flags_save_string;
1382                 }
1383                 {
1384                         uint32_t _flags_save_string = ndr->flags;
1385                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1386                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1387                         if (_ptr_comment) {
1388                                 NDR_PULL_ALLOC(ndr, r->comment);
1389                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1390                         } else {
1391                                 r->comment = NULL;
1392                         }
1393                         ndr->flags = _flags_save_string;
1394                 }
1395                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1396         }
1397         if (ndr_flags & NDR_BUFFERS) {
1398                 {
1399                         uint32_t _flags_save_string = ndr->flags;
1400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1401                         if (r->description) {
1402                                 uint32_t _relative_save_offset;
1403                                 _relative_save_offset = ndr->offset;
1404                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
1405                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
1406                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
1407                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
1408                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
1409                                 if (ndr->offset > ndr->relative_highest_offset) {
1410                                         ndr->relative_highest_offset = ndr->offset;
1411                                 }
1412                                 ndr->offset = _relative_save_offset;
1413                         }
1414                         ndr->flags = _flags_save_string;
1415                 }
1416                 {
1417                         uint32_t _flags_save_string = ndr->flags;
1418                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1419                         if (r->name) {
1420                                 uint32_t _relative_save_offset;
1421                                 _relative_save_offset = ndr->offset;
1422                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
1423                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1424                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
1425                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
1426                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
1427                                 if (ndr->offset > ndr->relative_highest_offset) {
1428                                         ndr->relative_highest_offset = ndr->offset;
1429                                 }
1430                                 ndr->offset = _relative_save_offset;
1431                         }
1432                         ndr->flags = _flags_save_string;
1433                 }
1434                 {
1435                         uint32_t _flags_save_string = ndr->flags;
1436                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1437                         if (r->comment) {
1438                                 uint32_t _relative_save_offset;
1439                                 _relative_save_offset = ndr->offset;
1440                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1441                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1442                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1443                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1444                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1445                                 if (ndr->offset > ndr->relative_highest_offset) {
1446                                         ndr->relative_highest_offset = ndr->offset;
1447                                 }
1448                                 ndr->offset = _relative_save_offset;
1449                         }
1450                         ndr->flags = _flags_save_string;
1451                 }
1452         }
1453         return NDR_ERR_SUCCESS;
1454 }
1455
1456 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
1457 {
1458         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
1459         ndr->depth++;
1460         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
1461         ndr_print_ptr(ndr, "description", r->description);
1462         ndr->depth++;
1463         if (r->description) {
1464                 ndr_print_string(ndr, "description", r->description);
1465         }
1466         ndr->depth--;
1467         ndr_print_ptr(ndr, "name", r->name);
1468         ndr->depth++;
1469         if (r->name) {
1470                 ndr_print_string(ndr, "name", r->name);
1471         }
1472         ndr->depth--;
1473         ndr_print_ptr(ndr, "comment", r->comment);
1474         ndr->depth++;
1475         if (r->comment) {
1476                 ndr_print_string(ndr, "comment", r->comment);
1477         }
1478         ndr->depth--;
1479         ndr->depth--;
1480 }
1481
1482 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo1(const struct spoolss_PrinterInfo1 *r, struct smb_iconv_convenience *ic, int flags)
1483 {
1484         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1, ic);
1485 }
1486
1487 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
1488 {
1489         if (ndr_flags & NDR_SCALARS) {
1490                 NDR_CHECK(ndr_push_align(ndr, 5));
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->servername));
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->printername));
1501                         ndr->flags = _flags_save_string;
1502                 }
1503                 {
1504                         uint32_t _flags_save_string = ndr->flags;
1505                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1506                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
1507                         ndr->flags = _flags_save_string;
1508                 }
1509                 {
1510                         uint32_t _flags_save_string = ndr->flags;
1511                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1512                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1513                         ndr->flags = _flags_save_string;
1514                 }
1515                 {
1516                         uint32_t _flags_save_string = ndr->flags;
1517                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1518                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1519                         ndr->flags = _flags_save_string;
1520                 }
1521                 {
1522                         uint32_t _flags_save_string = ndr->flags;
1523                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1524                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1525                         ndr->flags = _flags_save_string;
1526                 }
1527                 {
1528                         uint32_t _flags_save_string = ndr->flags;
1529                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1530                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1531                         ndr->flags = _flags_save_string;
1532                 }
1533                 {
1534                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
1535                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1536                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1537                         ndr->flags = _flags_save_spoolss_DeviceMode;
1538                 }
1539                 {
1540                         uint32_t _flags_save_string = ndr->flags;
1541                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1542                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1543                         ndr->flags = _flags_save_string;
1544                 }
1545                 {
1546                         uint32_t _flags_save_string = ndr->flags;
1547                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1548                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1549                         ndr->flags = _flags_save_string;
1550                 }
1551                 {
1552                         uint32_t _flags_save_string = ndr->flags;
1553                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1554                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1561                         ndr->flags = _flags_save_string;
1562                 }
1563                 {
1564                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1565                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1566                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1567                         ndr->flags = _flags_save_spoolss_security_descriptor;
1568                 }
1569                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1570                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1571                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1572                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1573                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1574                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1575                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1576                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1577                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1578         }
1579         if (ndr_flags & NDR_BUFFERS) {
1580                 {
1581                         uint32_t _flags_save_string = ndr->flags;
1582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1583                         if (r->servername) {
1584                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->servername));
1585                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1586                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->servername));
1587                         }
1588                         ndr->flags = _flags_save_string;
1589                 }
1590                 {
1591                         uint32_t _flags_save_string = ndr->flags;
1592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1593                         if (r->printername) {
1594                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
1595                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1596                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
1597                         }
1598                         ndr->flags = _flags_save_string;
1599                 }
1600                 {
1601                         uint32_t _flags_save_string = ndr->flags;
1602                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1603                         if (r->sharename) {
1604                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->sharename));
1605                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1606                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->sharename));
1607                         }
1608                         ndr->flags = _flags_save_string;
1609                 }
1610                 {
1611                         uint32_t _flags_save_string = ndr->flags;
1612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1613                         if (r->portname) {
1614                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->portname));
1615                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1616                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->portname));
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->drivername) {
1624                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->drivername));
1625                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1626                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->drivername));
1627                         }
1628                         ndr->flags = _flags_save_string;
1629                 }
1630                 {
1631                         uint32_t _flags_save_string = ndr->flags;
1632                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1633                         if (r->comment) {
1634                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->comment));
1635                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1636                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->comment));
1637                         }
1638                         ndr->flags = _flags_save_string;
1639                 }
1640                 {
1641                         uint32_t _flags_save_string = ndr->flags;
1642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1643                         if (r->location) {
1644                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->location));
1645                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1646                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->location));
1647                         }
1648                         ndr->flags = _flags_save_string;
1649                 }
1650                 {
1651                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
1652                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1653                         if (r->devmode) {
1654                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
1655                                 {
1656                                         struct ndr_push *_ndr_devmode;
1657                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1658                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1659                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1660                                 }
1661                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
1662                         }
1663                         ndr->flags = _flags_save_spoolss_DeviceMode;
1664                 }
1665                 {
1666                         uint32_t _flags_save_string = ndr->flags;
1667                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1668                         if (r->sepfile) {
1669                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->sepfile));
1670                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1671                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->sepfile));
1672                         }
1673                         ndr->flags = _flags_save_string;
1674                 }
1675                 {
1676                         uint32_t _flags_save_string = ndr->flags;
1677                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1678                         if (r->printprocessor) {
1679                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printprocessor));
1680                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1681                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printprocessor));
1682                         }
1683                         ndr->flags = _flags_save_string;
1684                 }
1685                 {
1686                         uint32_t _flags_save_string = ndr->flags;
1687                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1688                         if (r->datatype) {
1689                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->datatype));
1690                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1691                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->datatype));
1692                         }
1693                         ndr->flags = _flags_save_string;
1694                 }
1695                 {
1696                         uint32_t _flags_save_string = ndr->flags;
1697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1698                         if (r->parameters) {
1699                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->parameters));
1700                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1701                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->parameters));
1702                         }
1703                         ndr->flags = _flags_save_string;
1704                 }
1705                 {
1706                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1708                         if (r->secdesc) {
1709                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
1710                                 {
1711                                         struct ndr_push *_ndr_secdesc;
1712                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1713                                         NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1714                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1715                                 }
1716                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
1717                         }
1718                         ndr->flags = _flags_save_spoolss_security_descriptor;
1719                 }
1720         }
1721         return NDR_ERR_SUCCESS;
1722 }
1723
1724 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1725 {
1726         uint32_t _ptr_servername;
1727         TALLOC_CTX *_mem_save_servername_0;
1728         uint32_t _ptr_printername;
1729         TALLOC_CTX *_mem_save_printername_0;
1730         uint32_t _ptr_sharename;
1731         TALLOC_CTX *_mem_save_sharename_0;
1732         uint32_t _ptr_portname;
1733         TALLOC_CTX *_mem_save_portname_0;
1734         uint32_t _ptr_drivername;
1735         TALLOC_CTX *_mem_save_drivername_0;
1736         uint32_t _ptr_comment;
1737         TALLOC_CTX *_mem_save_comment_0;
1738         uint32_t _ptr_location;
1739         TALLOC_CTX *_mem_save_location_0;
1740         uint32_t _ptr_devmode;
1741         TALLOC_CTX *_mem_save_devmode_0;
1742         uint32_t _ptr_sepfile;
1743         TALLOC_CTX *_mem_save_sepfile_0;
1744         uint32_t _ptr_printprocessor;
1745         TALLOC_CTX *_mem_save_printprocessor_0;
1746         uint32_t _ptr_datatype;
1747         TALLOC_CTX *_mem_save_datatype_0;
1748         uint32_t _ptr_parameters;
1749         TALLOC_CTX *_mem_save_parameters_0;
1750         uint32_t _ptr_secdesc;
1751         TALLOC_CTX *_mem_save_secdesc_0;
1752         if (ndr_flags & NDR_SCALARS) {
1753                 NDR_CHECK(ndr_pull_align(ndr, 5));
1754                 {
1755                         uint32_t _flags_save_string = ndr->flags;
1756                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1757                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1758                         if (_ptr_servername) {
1759                                 NDR_PULL_ALLOC(ndr, r->servername);
1760                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1761                         } else {
1762                                 r->servername = NULL;
1763                         }
1764                         ndr->flags = _flags_save_string;
1765                 }
1766                 {
1767                         uint32_t _flags_save_string = ndr->flags;
1768                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1769                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1770                         if (_ptr_printername) {
1771                                 NDR_PULL_ALLOC(ndr, r->printername);
1772                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1773                         } else {
1774                                 r->printername = NULL;
1775                         }
1776                         ndr->flags = _flags_save_string;
1777                 }
1778                 {
1779                         uint32_t _flags_save_string = ndr->flags;
1780                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1781                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1782                         if (_ptr_sharename) {
1783                                 NDR_PULL_ALLOC(ndr, r->sharename);
1784                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1785                         } else {
1786                                 r->sharename = NULL;
1787                         }
1788                         ndr->flags = _flags_save_string;
1789                 }
1790                 {
1791                         uint32_t _flags_save_string = ndr->flags;
1792                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1793                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1794                         if (_ptr_portname) {
1795                                 NDR_PULL_ALLOC(ndr, r->portname);
1796                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1797                         } else {
1798                                 r->portname = NULL;
1799                         }
1800                         ndr->flags = _flags_save_string;
1801                 }
1802                 {
1803                         uint32_t _flags_save_string = ndr->flags;
1804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1805                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1806                         if (_ptr_drivername) {
1807                                 NDR_PULL_ALLOC(ndr, r->drivername);
1808                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1809                         } else {
1810                                 r->drivername = NULL;
1811                         }
1812                         ndr->flags = _flags_save_string;
1813                 }
1814                 {
1815                         uint32_t _flags_save_string = ndr->flags;
1816                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1817                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1818                         if (_ptr_comment) {
1819                                 NDR_PULL_ALLOC(ndr, r->comment);
1820                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1821                         } else {
1822                                 r->comment = NULL;
1823                         }
1824                         ndr->flags = _flags_save_string;
1825                 }
1826                 {
1827                         uint32_t _flags_save_string = ndr->flags;
1828                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1829                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1830                         if (_ptr_location) {
1831                                 NDR_PULL_ALLOC(ndr, r->location);
1832                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1833                         } else {
1834                                 r->location = NULL;
1835                         }
1836                         ndr->flags = _flags_save_string;
1837                 }
1838                 {
1839                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
1840                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1841                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1842                         if (_ptr_devmode) {
1843                                 NDR_PULL_ALLOC(ndr, r->devmode);
1844                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1845                         } else {
1846                                 r->devmode = NULL;
1847                         }
1848                         ndr->flags = _flags_save_spoolss_DeviceMode;
1849                 }
1850                 {
1851                         uint32_t _flags_save_string = ndr->flags;
1852                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1853                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1854                         if (_ptr_sepfile) {
1855                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1856                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1857                         } else {
1858                                 r->sepfile = NULL;
1859                         }
1860                         ndr->flags = _flags_save_string;
1861                 }
1862                 {
1863                         uint32_t _flags_save_string = ndr->flags;
1864                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1865                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1866                         if (_ptr_printprocessor) {
1867                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1868                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1869                         } else {
1870                                 r->printprocessor = NULL;
1871                         }
1872                         ndr->flags = _flags_save_string;
1873                 }
1874                 {
1875                         uint32_t _flags_save_string = ndr->flags;
1876                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1877                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1878                         if (_ptr_datatype) {
1879                                 NDR_PULL_ALLOC(ndr, r->datatype);
1880                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1881                         } else {
1882                                 r->datatype = NULL;
1883                         }
1884                         ndr->flags = _flags_save_string;
1885                 }
1886                 {
1887                         uint32_t _flags_save_string = ndr->flags;
1888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1889                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1890                         if (_ptr_parameters) {
1891                                 NDR_PULL_ALLOC(ndr, r->parameters);
1892                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1893                         } else {
1894                                 r->parameters = NULL;
1895                         }
1896                         ndr->flags = _flags_save_string;
1897                 }
1898                 {
1899                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1900                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1901                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1902                         if (_ptr_secdesc) {
1903                                 NDR_PULL_ALLOC(ndr, r->secdesc);
1904                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1905                         } else {
1906                                 r->secdesc = NULL;
1907                         }
1908                         ndr->flags = _flags_save_spoolss_security_descriptor;
1909                 }
1910                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1911                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1912                 if (r->priority > 99) {
1913                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1914                 }
1915                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1917                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1918                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1919                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1920                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1921                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1922         }
1923         if (ndr_flags & NDR_BUFFERS) {
1924                 {
1925                         uint32_t _flags_save_string = ndr->flags;
1926                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1927                         if (r->servername) {
1928                                 uint32_t _relative_save_offset;
1929                                 _relative_save_offset = ndr->offset;
1930                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1931                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1932                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1933                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1934                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1935                                 if (ndr->offset > ndr->relative_highest_offset) {
1936                                         ndr->relative_highest_offset = ndr->offset;
1937                                 }
1938                                 ndr->offset = _relative_save_offset;
1939                         }
1940                         ndr->flags = _flags_save_string;
1941                 }
1942                 {
1943                         uint32_t _flags_save_string = ndr->flags;
1944                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1945                         if (r->printername) {
1946                                 uint32_t _relative_save_offset;
1947                                 _relative_save_offset = ndr->offset;
1948                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1949                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1950                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1951                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1952                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1953                                 if (ndr->offset > ndr->relative_highest_offset) {
1954                                         ndr->relative_highest_offset = ndr->offset;
1955                                 }
1956                                 ndr->offset = _relative_save_offset;
1957                         }
1958                         ndr->flags = _flags_save_string;
1959                 }
1960                 {
1961                         uint32_t _flags_save_string = ndr->flags;
1962                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1963                         if (r->sharename) {
1964                                 uint32_t _relative_save_offset;
1965                                 _relative_save_offset = ndr->offset;
1966                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1967                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1968                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1969                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1970                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1971                                 if (ndr->offset > ndr->relative_highest_offset) {
1972                                         ndr->relative_highest_offset = ndr->offset;
1973                                 }
1974                                 ndr->offset = _relative_save_offset;
1975                         }
1976                         ndr->flags = _flags_save_string;
1977                 }
1978                 {
1979                         uint32_t _flags_save_string = ndr->flags;
1980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1981                         if (r->portname) {
1982                                 uint32_t _relative_save_offset;
1983                                 _relative_save_offset = ndr->offset;
1984                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1985                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1986                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1987                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1988                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1989                                 if (ndr->offset > ndr->relative_highest_offset) {
1990                                         ndr->relative_highest_offset = ndr->offset;
1991                                 }
1992                                 ndr->offset = _relative_save_offset;
1993                         }
1994                         ndr->flags = _flags_save_string;
1995                 }
1996                 {
1997                         uint32_t _flags_save_string = ndr->flags;
1998                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1999                         if (r->drivername) {
2000                                 uint32_t _relative_save_offset;
2001                                 _relative_save_offset = ndr->offset;
2002                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
2003                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2004                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
2005                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
2006                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
2007                                 if (ndr->offset > ndr->relative_highest_offset) {
2008                                         ndr->relative_highest_offset = ndr->offset;
2009                                 }
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->comment) {
2018                                 uint32_t _relative_save_offset;
2019                                 _relative_save_offset = ndr->offset;
2020                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
2021                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
2022                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
2023                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
2024                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
2025                                 if (ndr->offset > ndr->relative_highest_offset) {
2026                                         ndr->relative_highest_offset = ndr->offset;
2027                                 }
2028                                 ndr->offset = _relative_save_offset;
2029                         }
2030                         ndr->flags = _flags_save_string;
2031                 }
2032                 {
2033                         uint32_t _flags_save_string = ndr->flags;
2034                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2035                         if (r->location) {
2036                                 uint32_t _relative_save_offset;
2037                                 _relative_save_offset = ndr->offset;
2038                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
2039                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
2040                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
2041                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
2042                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
2043                                 if (ndr->offset > ndr->relative_highest_offset) {
2044                                         ndr->relative_highest_offset = ndr->offset;
2045                                 }
2046                                 ndr->offset = _relative_save_offset;
2047                         }
2048                         ndr->flags = _flags_save_string;
2049                 }
2050                 {
2051                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2052                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2053                         if (r->devmode) {
2054                                 uint32_t _relative_save_offset;
2055                                 _relative_save_offset = ndr->offset;
2056                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2057                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2058                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2059                                 {
2060                                         struct ndr_pull *_ndr_devmode;
2061                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2062                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2063                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2064                                 }
2065                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2066                                 if (ndr->offset > ndr->relative_highest_offset) {
2067                                         ndr->relative_highest_offset = ndr->offset;
2068                                 }
2069                                 ndr->offset = _relative_save_offset;
2070                         }
2071                         ndr->flags = _flags_save_spoolss_DeviceMode;
2072                 }
2073                 {
2074                         uint32_t _flags_save_string = ndr->flags;
2075                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2076                         if (r->sepfile) {
2077                                 uint32_t _relative_save_offset;
2078                                 _relative_save_offset = ndr->offset;
2079                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
2080                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
2081                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
2082                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
2083                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
2084                                 if (ndr->offset > ndr->relative_highest_offset) {
2085                                         ndr->relative_highest_offset = ndr->offset;
2086                                 }
2087                                 ndr->offset = _relative_save_offset;
2088                         }
2089                         ndr->flags = _flags_save_string;
2090                 }
2091                 {
2092                         uint32_t _flags_save_string = ndr->flags;
2093                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2094                         if (r->printprocessor) {
2095                                 uint32_t _relative_save_offset;
2096                                 _relative_save_offset = ndr->offset;
2097                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
2098                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
2099                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
2100                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
2101                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
2102                                 if (ndr->offset > ndr->relative_highest_offset) {
2103                                         ndr->relative_highest_offset = ndr->offset;
2104                                 }
2105                                 ndr->offset = _relative_save_offset;
2106                         }
2107                         ndr->flags = _flags_save_string;
2108                 }
2109                 {
2110                         uint32_t _flags_save_string = ndr->flags;
2111                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2112                         if (r->datatype) {
2113                                 uint32_t _relative_save_offset;
2114                                 _relative_save_offset = ndr->offset;
2115                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
2116                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
2117                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
2118                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
2119                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
2120                                 if (ndr->offset > ndr->relative_highest_offset) {
2121                                         ndr->relative_highest_offset = ndr->offset;
2122                                 }
2123                                 ndr->offset = _relative_save_offset;
2124                         }
2125                         ndr->flags = _flags_save_string;
2126                 }
2127                 {
2128                         uint32_t _flags_save_string = ndr->flags;
2129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2130                         if (r->parameters) {
2131                                 uint32_t _relative_save_offset;
2132                                 _relative_save_offset = ndr->offset;
2133                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
2134                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
2135                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
2136                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
2137                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
2138                                 if (ndr->offset > ndr->relative_highest_offset) {
2139                                         ndr->relative_highest_offset = ndr->offset;
2140                                 }
2141                                 ndr->offset = _relative_save_offset;
2142                         }
2143                         ndr->flags = _flags_save_string;
2144                 }
2145                 {
2146                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
2147                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2148                         if (r->secdesc) {
2149                                 uint32_t _relative_save_offset;
2150                                 _relative_save_offset = ndr->offset;
2151                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2152                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2153                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2154                                 {
2155                                         struct ndr_pull *_ndr_secdesc;
2156                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2157                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2158                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2159                                 }
2160                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2161                                 if (ndr->offset > ndr->relative_highest_offset) {
2162                                         ndr->relative_highest_offset = ndr->offset;
2163                                 }
2164                                 ndr->offset = _relative_save_offset;
2165                         }
2166                         ndr->flags = _flags_save_spoolss_security_descriptor;
2167                 }
2168         }
2169         return NDR_ERR_SUCCESS;
2170 }
2171
2172 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
2173 {
2174         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
2175         ndr->depth++;
2176         ndr_print_ptr(ndr, "servername", r->servername);
2177         ndr->depth++;
2178         if (r->servername) {
2179                 ndr_print_string(ndr, "servername", r->servername);
2180         }
2181         ndr->depth--;
2182         ndr_print_ptr(ndr, "printername", r->printername);
2183         ndr->depth++;
2184         if (r->printername) {
2185                 ndr_print_string(ndr, "printername", r->printername);
2186         }
2187         ndr->depth--;
2188         ndr_print_ptr(ndr, "sharename", r->sharename);
2189         ndr->depth++;
2190         if (r->sharename) {
2191                 ndr_print_string(ndr, "sharename", r->sharename);
2192         }
2193         ndr->depth--;
2194         ndr_print_ptr(ndr, "portname", r->portname);
2195         ndr->depth++;
2196         if (r->portname) {
2197                 ndr_print_string(ndr, "portname", r->portname);
2198         }
2199         ndr->depth--;
2200         ndr_print_ptr(ndr, "drivername", r->drivername);
2201         ndr->depth++;
2202         if (r->drivername) {
2203                 ndr_print_string(ndr, "drivername", r->drivername);
2204         }
2205         ndr->depth--;
2206         ndr_print_ptr(ndr, "comment", r->comment);
2207         ndr->depth++;
2208         if (r->comment) {
2209                 ndr_print_string(ndr, "comment", r->comment);
2210         }
2211         ndr->depth--;
2212         ndr_print_ptr(ndr, "location", r->location);
2213         ndr->depth++;
2214         if (r->location) {
2215                 ndr_print_string(ndr, "location", r->location);
2216         }
2217         ndr->depth--;
2218         ndr_print_ptr(ndr, "devmode", r->devmode);
2219         ndr->depth++;
2220         if (r->devmode) {
2221                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2222         }
2223         ndr->depth--;
2224         ndr_print_ptr(ndr, "sepfile", r->sepfile);
2225         ndr->depth++;
2226         if (r->sepfile) {
2227                 ndr_print_string(ndr, "sepfile", r->sepfile);
2228         }
2229         ndr->depth--;
2230         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
2231         ndr->depth++;
2232         if (r->printprocessor) {
2233                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
2234         }
2235         ndr->depth--;
2236         ndr_print_ptr(ndr, "datatype", r->datatype);
2237         ndr->depth++;
2238         if (r->datatype) {
2239                 ndr_print_string(ndr, "datatype", r->datatype);
2240         }
2241         ndr->depth--;
2242         ndr_print_ptr(ndr, "parameters", r->parameters);
2243         ndr->depth++;
2244         if (r->parameters) {
2245                 ndr_print_string(ndr, "parameters", r->parameters);
2246         }
2247         ndr->depth--;
2248         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2249         ndr->depth++;
2250         if (r->secdesc) {
2251                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
2252         }
2253         ndr->depth--;
2254         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2255         ndr_print_uint32(ndr, "priority", r->priority);
2256         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
2257         ndr_print_uint32(ndr, "starttime", r->starttime);
2258         ndr_print_uint32(ndr, "untiltime", r->untiltime);
2259         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2260         ndr_print_uint32(ndr, "cjobs", r->cjobs);
2261         ndr_print_uint32(ndr, "averageppm", r->averageppm);
2262         ndr->depth--;
2263 }
2264
2265 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo2(const struct spoolss_PrinterInfo2 *r, struct smb_iconv_convenience *ic, int flags)
2266 {
2267         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2, ic);
2268 }
2269
2270 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
2271 {
2272         if (ndr_flags & NDR_SCALARS) {
2273                 NDR_CHECK(ndr_push_align(ndr, 5));
2274                 {
2275                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
2276                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2277                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
2278                         ndr->flags = _flags_save_spoolss_security_descriptor;
2279                 }
2280                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2281         }
2282         if (ndr_flags & NDR_BUFFERS) {
2283                 {
2284                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
2285                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2286                         if (r->secdesc) {
2287                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
2288                                 {
2289                                         struct ndr_push *_ndr_secdesc;
2290                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2291                                         NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2292                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2293                                 }
2294                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
2295                         }
2296                         ndr->flags = _flags_save_spoolss_security_descriptor;
2297                 }
2298         }
2299         return NDR_ERR_SUCCESS;
2300 }
2301
2302 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
2303 {
2304         uint32_t _ptr_secdesc;
2305         TALLOC_CTX *_mem_save_secdesc_0;
2306         if (ndr_flags & NDR_SCALARS) {
2307                 NDR_CHECK(ndr_pull_align(ndr, 5));
2308                 {
2309                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
2310                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2311                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
2312                         if (_ptr_secdesc) {
2313                                 NDR_PULL_ALLOC(ndr, r->secdesc);
2314                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
2315                         } else {
2316                                 r->secdesc = NULL;
2317                         }
2318                         ndr->flags = _flags_save_spoolss_security_descriptor;
2319                 }
2320                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2321         }
2322         if (ndr_flags & NDR_BUFFERS) {
2323                 {
2324                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
2325                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2326                         if (r->secdesc) {
2327                                 uint32_t _relative_save_offset;
2328                                 _relative_save_offset = ndr->offset;
2329                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2330                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2331                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2332                                 {
2333                                         struct ndr_pull *_ndr_secdesc;
2334                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2335                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2336                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2337                                 }
2338                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2339                                 if (ndr->offset > ndr->relative_highest_offset) {
2340                                         ndr->relative_highest_offset = ndr->offset;
2341                                 }
2342                                 ndr->offset = _relative_save_offset;
2343                         }
2344                         ndr->flags = _flags_save_spoolss_security_descriptor;
2345                 }
2346         }
2347         return NDR_ERR_SUCCESS;
2348 }
2349
2350 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
2351 {
2352         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
2353         ndr->depth++;
2354         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2355         ndr->depth++;
2356         if (r->secdesc) {
2357                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
2358         }
2359         ndr->depth--;
2360         ndr->depth--;
2361 }
2362
2363 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo3(const struct spoolss_PrinterInfo3 *r, struct smb_iconv_convenience *ic, int flags)
2364 {
2365         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo3, ic);
2366 }
2367
2368 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
2369 {
2370         if (ndr_flags & NDR_SCALARS) {
2371                 NDR_CHECK(ndr_push_align(ndr, 5));
2372                 {
2373                         uint32_t _flags_save_string = ndr->flags;
2374                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2375                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2376                         ndr->flags = _flags_save_string;
2377                 }
2378                 {
2379                         uint32_t _flags_save_string = ndr->flags;
2380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2381                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
2382                         ndr->flags = _flags_save_string;
2383                 }
2384                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2385                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2386         }
2387         if (ndr_flags & NDR_BUFFERS) {
2388                 {
2389                         uint32_t _flags_save_string = ndr->flags;
2390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2391                         if (r->printername) {
2392                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
2393                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2394                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
2395                         }
2396                         ndr->flags = _flags_save_string;
2397                 }
2398                 {
2399                         uint32_t _flags_save_string = ndr->flags;
2400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2401                         if (r->servername) {
2402                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->servername));
2403                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
2404                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->servername));
2405                         }
2406                         ndr->flags = _flags_save_string;
2407                 }
2408         }
2409         return NDR_ERR_SUCCESS;
2410 }
2411
2412 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
2413 {
2414         uint32_t _ptr_printername;
2415         TALLOC_CTX *_mem_save_printername_0;
2416         uint32_t _ptr_servername;
2417         TALLOC_CTX *_mem_save_servername_0;
2418         if (ndr_flags & NDR_SCALARS) {
2419                 NDR_CHECK(ndr_pull_align(ndr, 5));
2420                 {
2421                         uint32_t _flags_save_string = ndr->flags;
2422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2423                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2424                         if (_ptr_printername) {
2425                                 NDR_PULL_ALLOC(ndr, r->printername);
2426                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2427                         } else {
2428                                 r->printername = NULL;
2429                         }
2430                         ndr->flags = _flags_save_string;
2431                 }
2432                 {
2433                         uint32_t _flags_save_string = ndr->flags;
2434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2435                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
2436                         if (_ptr_servername) {
2437                                 NDR_PULL_ALLOC(ndr, r->servername);
2438                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
2439                         } else {
2440                                 r->servername = NULL;
2441                         }
2442                         ndr->flags = _flags_save_string;
2443                 }
2444                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2445                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2446         }
2447         if (ndr_flags & NDR_BUFFERS) {
2448                 {
2449                         uint32_t _flags_save_string = ndr->flags;
2450                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2451                         if (r->printername) {
2452                                 uint32_t _relative_save_offset;
2453                                 _relative_save_offset = ndr->offset;
2454                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2455                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2456                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2457                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2458                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2459                                 if (ndr->offset > ndr->relative_highest_offset) {
2460                                         ndr->relative_highest_offset = ndr->offset;
2461                                 }
2462                                 ndr->offset = _relative_save_offset;
2463                         }
2464                         ndr->flags = _flags_save_string;
2465                 }
2466                 {
2467                         uint32_t _flags_save_string = ndr->flags;
2468                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2469                         if (r->servername) {
2470                                 uint32_t _relative_save_offset;
2471                                 _relative_save_offset = ndr->offset;
2472                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
2473                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2474                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
2475                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
2476                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
2477                                 if (ndr->offset > ndr->relative_highest_offset) {
2478                                         ndr->relative_highest_offset = ndr->offset;
2479                                 }
2480                                 ndr->offset = _relative_save_offset;
2481                         }
2482                         ndr->flags = _flags_save_string;
2483                 }
2484         }
2485         return NDR_ERR_SUCCESS;
2486 }
2487
2488 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
2489 {
2490         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
2491         ndr->depth++;
2492         ndr_print_ptr(ndr, "printername", r->printername);
2493         ndr->depth++;
2494         if (r->printername) {
2495                 ndr_print_string(ndr, "printername", r->printername);
2496         }
2497         ndr->depth--;
2498         ndr_print_ptr(ndr, "servername", r->servername);
2499         ndr->depth++;
2500         if (r->servername) {
2501                 ndr_print_string(ndr, "servername", r->servername);
2502         }
2503         ndr->depth--;
2504         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2505         ndr->depth--;
2506 }
2507
2508 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo4(const struct spoolss_PrinterInfo4 *r, struct smb_iconv_convenience *ic, int flags)
2509 {
2510         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo4, ic);
2511 }
2512
2513 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
2514 {
2515         if (ndr_flags & NDR_SCALARS) {
2516                 NDR_CHECK(ndr_push_align(ndr, 5));
2517                 {
2518                         uint32_t _flags_save_string = ndr->flags;
2519                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2520                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2521                         ndr->flags = _flags_save_string;
2522                 }
2523                 {
2524                         uint32_t _flags_save_string = ndr->flags;
2525                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2526                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
2527                         ndr->flags = _flags_save_string;
2528                 }
2529                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
2531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
2532                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2533         }
2534         if (ndr_flags & NDR_BUFFERS) {
2535                 {
2536                         uint32_t _flags_save_string = ndr->flags;
2537                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2538                         if (r->printername) {
2539                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
2540                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2541                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
2542                         }
2543                         ndr->flags = _flags_save_string;
2544                 }
2545                 {
2546                         uint32_t _flags_save_string = ndr->flags;
2547                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2548                         if (r->portname) {
2549                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->portname));
2550                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
2551                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->portname));
2552                         }
2553                         ndr->flags = _flags_save_string;
2554                 }
2555         }
2556         return NDR_ERR_SUCCESS;
2557 }
2558
2559 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
2560 {
2561         uint32_t _ptr_printername;
2562         TALLOC_CTX *_mem_save_printername_0;
2563         uint32_t _ptr_portname;
2564         TALLOC_CTX *_mem_save_portname_0;
2565         if (ndr_flags & NDR_SCALARS) {
2566                 NDR_CHECK(ndr_pull_align(ndr, 5));
2567                 {
2568                         uint32_t _flags_save_string = ndr->flags;
2569                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2570                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2571                         if (_ptr_printername) {
2572                                 NDR_PULL_ALLOC(ndr, r->printername);
2573                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2574                         } else {
2575                                 r->printername = NULL;
2576                         }
2577                         ndr->flags = _flags_save_string;
2578                 }
2579                 {
2580                         uint32_t _flags_save_string = ndr->flags;
2581                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2582                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
2583                         if (_ptr_portname) {
2584                                 NDR_PULL_ALLOC(ndr, r->portname);
2585                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
2586                         } else {
2587                                 r->portname = NULL;
2588                         }
2589                         ndr->flags = _flags_save_string;
2590                 }
2591                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2592                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
2593                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
2594                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2595         }
2596         if (ndr_flags & NDR_BUFFERS) {
2597                 {
2598                         uint32_t _flags_save_string = ndr->flags;
2599                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2600                         if (r->printername) {
2601                                 uint32_t _relative_save_offset;
2602                                 _relative_save_offset = ndr->offset;
2603                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2604                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2605                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2606                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2607                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2608                                 if (ndr->offset > ndr->relative_highest_offset) {
2609                                         ndr->relative_highest_offset = ndr->offset;
2610                                 }
2611                                 ndr->offset = _relative_save_offset;
2612                         }
2613                         ndr->flags = _flags_save_string;
2614                 }
2615                 {
2616                         uint32_t _flags_save_string = ndr->flags;
2617                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2618                         if (r->portname) {
2619                                 uint32_t _relative_save_offset;
2620                                 _relative_save_offset = ndr->offset;
2621                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
2622                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2623                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
2624                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
2625                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
2626                                 if (ndr->offset > ndr->relative_highest_offset) {
2627                                         ndr->relative_highest_offset = ndr->offset;
2628                                 }
2629                                 ndr->offset = _relative_save_offset;
2630                         }
2631                         ndr->flags = _flags_save_string;
2632                 }
2633         }
2634         return NDR_ERR_SUCCESS;
2635 }
2636
2637 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
2638 {
2639         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
2640         ndr->depth++;
2641         ndr_print_ptr(ndr, "printername", r->printername);
2642         ndr->depth++;
2643         if (r->printername) {
2644                 ndr_print_string(ndr, "printername", r->printername);
2645         }
2646         ndr->depth--;
2647         ndr_print_ptr(ndr, "portname", r->portname);
2648         ndr->depth++;
2649         if (r->portname) {
2650                 ndr_print_string(ndr, "portname", r->portname);
2651         }
2652         ndr->depth--;
2653         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2654         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
2655         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
2656         ndr->depth--;
2657 }
2658
2659 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo5(const struct spoolss_PrinterInfo5 *r, struct smb_iconv_convenience *ic, int flags)
2660 {
2661         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5, ic);
2662 }
2663
2664 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
2665 {
2666         if (ndr_flags & NDR_SCALARS) {
2667                 NDR_CHECK(ndr_push_align(ndr, 4));
2668                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
2669                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2670         }
2671         if (ndr_flags & NDR_BUFFERS) {
2672         }
2673         return NDR_ERR_SUCCESS;
2674 }
2675
2676 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2677 {
2678         if (ndr_flags & NDR_SCALARS) {
2679                 NDR_CHECK(ndr_pull_align(ndr, 4));
2680                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2681                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2682         }
2683         if (ndr_flags & NDR_BUFFERS) {
2684         }
2685         return NDR_ERR_SUCCESS;
2686 }
2687
2688 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2689 {
2690         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2691         ndr->depth++;
2692         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2693         ndr->depth--;
2694 }
2695
2696 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo6(const struct spoolss_PrinterInfo6 *r, struct smb_iconv_convenience *ic, int flags)
2697 {
2698         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo6, ic);
2699 }
2700
2701 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2702 {
2703         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2704         return NDR_ERR_SUCCESS;
2705 }
2706
2707 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2708 {
2709         uint32_t v;
2710         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2711         *r = v;
2712         return NDR_ERR_SUCCESS;
2713 }
2714
2715 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2716 {
2717         ndr_print_uint32(ndr, name, r);
2718         ndr->depth++;
2719         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2720         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2721         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2722         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2723         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2724         ndr->depth--;
2725 }
2726
2727 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2728 {
2729         if (ndr_flags & NDR_SCALARS) {
2730                 NDR_CHECK(ndr_push_align(ndr, 5));
2731                 {
2732                         uint32_t _flags_save_string = ndr->flags;
2733                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2734                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2735                         ndr->flags = _flags_save_string;
2736                 }
2737                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2738                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2739         }
2740         if (ndr_flags & NDR_BUFFERS) {
2741                 {
2742                         uint32_t _flags_save_string = ndr->flags;
2743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2744                         if (r->guid) {
2745                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->guid));
2746                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2747                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->guid));
2748                         }
2749                         ndr->flags = _flags_save_string;
2750                 }
2751         }
2752         return NDR_ERR_SUCCESS;
2753 }
2754
2755 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2756 {
2757         uint32_t _ptr_guid;
2758         TALLOC_CTX *_mem_save_guid_0;
2759         if (ndr_flags & NDR_SCALARS) {
2760                 NDR_CHECK(ndr_pull_align(ndr, 5));
2761                 {
2762                         uint32_t _flags_save_string = ndr->flags;
2763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2764                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2765                         if (_ptr_guid) {
2766                                 NDR_PULL_ALLOC(ndr, r->guid);
2767                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2768                         } else {
2769                                 r->guid = NULL;
2770                         }
2771                         ndr->flags = _flags_save_string;
2772                 }
2773                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2774                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2775         }
2776         if (ndr_flags & NDR_BUFFERS) {
2777                 {
2778                         uint32_t _flags_save_string = ndr->flags;
2779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2780                         if (r->guid) {
2781                                 uint32_t _relative_save_offset;
2782                                 _relative_save_offset = ndr->offset;
2783                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2784                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2785                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2786                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2787                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2788                                 if (ndr->offset > ndr->relative_highest_offset) {
2789                                         ndr->relative_highest_offset = ndr->offset;
2790                                 }
2791                                 ndr->offset = _relative_save_offset;
2792                         }
2793                         ndr->flags = _flags_save_string;
2794                 }
2795         }
2796         return NDR_ERR_SUCCESS;
2797 }
2798
2799 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2800 {
2801         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2802         ndr->depth++;
2803         ndr_print_ptr(ndr, "guid", r->guid);
2804         ndr->depth++;
2805         if (r->guid) {
2806                 ndr_print_string(ndr, "guid", r->guid);
2807         }
2808         ndr->depth--;
2809         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2810         ndr->depth--;
2811 }
2812
2813 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo7(const struct spoolss_PrinterInfo7 *r, struct smb_iconv_convenience *ic, int flags)
2814 {
2815         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo7, ic);
2816 }
2817
2818 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2819 {
2820         if (ndr_flags & NDR_SCALARS) {
2821                 NDR_CHECK(ndr_push_align(ndr, 5));
2822                 {
2823                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2825                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2826                         ndr->flags = _flags_save_spoolss_DeviceMode;
2827                 }
2828                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2829         }
2830         if (ndr_flags & NDR_BUFFERS) {
2831                 {
2832                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2834                         if (r->devmode) {
2835                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
2836                                 {
2837                                         struct ndr_push *_ndr_devmode;
2838                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2839                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2840                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2841                                 }
2842                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
2843                         }
2844                         ndr->flags = _flags_save_spoolss_DeviceMode;
2845                 }
2846         }
2847         return NDR_ERR_SUCCESS;
2848 }
2849
2850 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2851 {
2852         uint32_t _ptr_devmode;
2853         TALLOC_CTX *_mem_save_devmode_0;
2854         if (ndr_flags & NDR_SCALARS) {
2855                 NDR_CHECK(ndr_pull_align(ndr, 5));
2856                 {
2857                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2858                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2859                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2860                         if (_ptr_devmode) {
2861                                 NDR_PULL_ALLOC(ndr, r->devmode);
2862                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2863                         } else {
2864                                 r->devmode = NULL;
2865                         }
2866                         ndr->flags = _flags_save_spoolss_DeviceMode;
2867                 }
2868                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2869         }
2870         if (ndr_flags & NDR_BUFFERS) {
2871                 {
2872                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2874                         if (r->devmode) {
2875                                 uint32_t _relative_save_offset;
2876                                 _relative_save_offset = ndr->offset;
2877                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2878                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2879                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2880                                 {
2881                                         struct ndr_pull *_ndr_devmode;
2882                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2883                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2884                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2885                                 }
2886                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2887                                 if (ndr->offset > ndr->relative_highest_offset) {
2888                                         ndr->relative_highest_offset = ndr->offset;
2889                                 }
2890                                 ndr->offset = _relative_save_offset;
2891                         }
2892                         ndr->flags = _flags_save_spoolss_DeviceMode;
2893                 }
2894         }
2895         return NDR_ERR_SUCCESS;
2896 }
2897
2898 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2899 {
2900         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2901         ndr->depth++;
2902         ndr_print_ptr(ndr, "devmode", r->devmode);
2903         ndr->depth++;
2904         if (r->devmode) {
2905                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2906         }
2907         ndr->depth--;
2908         ndr->depth--;
2909 }
2910
2911 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2912 {
2913         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2914         {
2915                 uint32_t _flags_save_UNION = ndr->flags;
2916                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
2917                 if (ndr_flags & NDR_SCALARS) {
2918                         int level = ndr_push_get_switch_value(ndr, r);
2919                         NDR_CHECK(ndr_push_union_align(ndr, 5));
2920                         switch (level) {
2921                                 case 0: {
2922                                         NDR_CHECK(ndr_push_align(ndr, 5));
2923                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2924                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2925                                 break; }
2926
2927                                 case 1: {
2928                                         NDR_CHECK(ndr_push_align(ndr, 5));
2929                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2930                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2931                                 break; }
2932
2933                                 case 2: {
2934                                         NDR_CHECK(ndr_push_align(ndr, 5));
2935                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2936                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2937                                 break; }
2938
2939                                 case 3: {
2940                                         NDR_CHECK(ndr_push_align(ndr, 5));
2941                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2942                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2943                                 break; }
2944
2945                                 case 4: {
2946                                         NDR_CHECK(ndr_push_align(ndr, 5));
2947                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2948                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2949                                 break; }
2950
2951                                 case 5: {
2952                                         NDR_CHECK(ndr_push_align(ndr, 5));
2953                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2954                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2955                                 break; }
2956
2957                                 case 6: {
2958                                         NDR_CHECK(ndr_push_align(ndr, 4));
2959                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2960                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2961                                 break; }
2962
2963                                 case 7: {
2964                                         NDR_CHECK(ndr_push_align(ndr, 5));
2965                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2966                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2967                                 break; }
2968
2969                                 case 8: {
2970                                         NDR_CHECK(ndr_push_align(ndr, 5));
2971                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2972                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2973                                 break; }
2974
2975                                 case 9: {
2976                                         NDR_CHECK(ndr_push_align(ndr, 5));
2977                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2978                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2979                                 break; }
2980
2981                                 default: {
2982                                 break; }
2983
2984                         }
2985                 }
2986                 if (ndr_flags & NDR_BUFFERS) {
2987                         int level = ndr_push_get_switch_value(ndr, r);
2988                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2989                         switch (level) {
2990                                 case 0:
2991                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2992                                 break;
2993
2994                                 case 1:
2995                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2996                                 break;
2997
2998                                 case 2:
2999                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
3000                                 break;
3001
3002                                 case 3:
3003                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
3004                                 break;
3005
3006                                 case 4:
3007                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
3008                                 break;
3009
3010                                 case 5:
3011                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
3012                                 break;
3013
3014                                 case 6:
3015                                 break;
3016
3017                                 case 7:
3018                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
3019                                 break;
3020
3021                                 case 8:
3022                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
3023                                 break;
3024
3025                                 case 9:
3026                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
3027                                 break;
3028
3029                                 default:
3030                                 break;
3031
3032                         }
3033                 }
3034                 ndr->flags = _flags_save_UNION;
3035         }
3036         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
3037         return NDR_ERR_SUCCESS;
3038 }
3039
3040 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
3041 {
3042         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
3043         int level;
3044         {
3045                 uint32_t _flags_save_UNION = ndr->flags;
3046                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
3047                 level = ndr_pull_get_switch_value(ndr, r);
3048                 if (ndr_flags & NDR_SCALARS) {
3049                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
3050                         switch (level) {
3051                                 case 0: {
3052                                         NDR_CHECK(ndr_pull_align(ndr, 5));
3053                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3054                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
3055                                 break; }
3056
3057                                 case 1: {
3058                                         NDR_CHECK(ndr_pull_align(ndr, 5));
3059                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3060                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
3061                                 break; }
3062
3063                                 case 2: {
3064                                         NDR_CHECK(ndr_pull_align(ndr, 5));
3065                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3066                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
3067                                 break; }
3068
3069                                 case 3: {
3070                                         NDR_CHECK(ndr_pull_align(ndr, 5));
3071                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3072                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
3073                                 break; }
3074
3075                                 case 4: {
3076                                         NDR_CHECK(ndr_pull_align(ndr, 5));
3077                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3078                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
3079                                 break; }
3080
3081                                 case 5: {
3082                                         NDR_CHECK(ndr_pull_align(ndr, 5));
3083                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3084                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
3085                                 break; }
3086
3087                                 case 6: {
3088                                         NDR_CHECK(ndr_pull_align(ndr, 4));
3089                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3090                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
3091                                 break; }
3092
3093                                 case 7: {
3094                                         NDR_CHECK(ndr_pull_align(ndr, 5));
3095                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3096                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
3097                                 break; }
3098
3099                                 case 8: {
3100                                         NDR_CHECK(ndr_pull_align(ndr, 5));
3101                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3102                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
3103                                 break; }
3104
3105                                 case 9: {
3106                                         NDR_CHECK(ndr_pull_align(ndr, 5));
3107                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3108                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
3109                                 break; }
3110
3111                                 default: {
3112                                 break; }
3113
3114                         }
3115                 }
3116                 if (ndr_flags & NDR_BUFFERS) {
3117                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
3118                         switch (level) {
3119                                 case 0:
3120                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
3121                                 break;
3122
3123                                 case 1:
3124                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
3125                                 break;
3126
3127                                 case 2:
3128                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
3129                                 break;
3130
3131                                 case 3:
3132                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
3133                                 break;
3134
3135                                 case 4:
3136                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
3137                                 break;
3138
3139                                 case 5:
3140                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
3141                                 break;
3142
3143                                 case 6:
3144                                 break;
3145
3146                                 case 7:
3147                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
3148                                 break;
3149
3150                                 case 8:
3151                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
3152                                 break;
3153
3154                                 case 9:
3155                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
3156                                 break;
3157
3158                                 default:
3159                                 break;
3160
3161                         }
3162                 }
3163                 ndr->flags = _flags_save_UNION;
3164         }
3165         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
3166         return NDR_ERR_SUCCESS;
3167 }
3168
3169 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
3170 {
3171         int level;
3172         {
3173                 uint32_t _flags_save_UNION = ndr->flags;
3174                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
3175                 level = ndr_print_get_switch_value(ndr, r);
3176                 ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
3177                 switch (level) {
3178                         case 0:
3179                                 ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
3180                         break;
3181
3182                         case 1:
3183                                 ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
3184                         break;
3185
3186                         case 2:
3187                                 ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
3188                         break;
3189
3190                         case 3:
3191                                 ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
3192                         break;
3193
3194                         case 4:
3195                                 ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
3196                         break;
3197
3198                         case 5:
3199                                 ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
3200                         break;
3201
3202                         case 6:
3203                                 ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
3204                         break;
3205
3206                         case 7:
3207                                 ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
3208                         break;
3209
3210                         case 8:
3211                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
3212                         break;
3213
3214                         case 9:
3215                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
3216                         break;
3217
3218                         default:
3219                         break;
3220
3221                 }
3222                 ndr->flags = _flags_save_UNION;
3223         }
3224 }
3225
3226 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo(const union spoolss_PrinterInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
3227 {
3228         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
3229         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo, ic);
3230 }
3231
3232 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
3233 {
3234         if (ndr_flags & NDR_SCALARS) {
3235                 NDR_CHECK(ndr_push_align(ndr, 5));
3236                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3237                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
3238                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3239         }
3240         if (ndr_flags & NDR_BUFFERS) {
3241                 if (r->devmode) {
3242                         {
3243                                 struct ndr_push *_ndr_devmode;
3244                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3245                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3246                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3247                         }
3248                 }
3249         }
3250         return NDR_ERR_SUCCESS;
3251 }
3252
3253 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
3254 {
3255         uint32_t _ptr_devmode;
3256         TALLOC_CTX *_mem_save_devmode_0;
3257         if (ndr_flags & NDR_SCALARS) {
3258                 NDR_CHECK(ndr_pull_align(ndr, 5));
3259                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
3260                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3261                 if (_ptr_devmode) {
3262                         NDR_PULL_ALLOC(ndr, r->devmode);
3263                 } else {
3264                         r->devmode = NULL;
3265                 }
3266                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3267         }
3268         if (ndr_flags & NDR_BUFFERS) {
3269                 if (r->devmode) {
3270                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3271                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3272                         {
3273                                 struct ndr_pull *_ndr_devmode;
3274                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
3275                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3276                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
3277                         }
3278                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3279                 }
3280         }
3281         return NDR_ERR_SUCCESS;
3282 }
3283
3284 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
3285 {
3286         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
3287         ndr->depth++;
3288         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);
3289         ndr_print_ptr(ndr, "devmode", r->devmode);
3290         ndr->depth++;
3291         if (r->devmode) {
3292                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3293         }
3294         ndr->depth--;
3295         ndr->depth--;
3296 }
3297
3298 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
3299 {
3300         if (ndr_flags & NDR_SCALARS) {
3301                 NDR_CHECK(ndr_push_align(ndr, 5));
3302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3303                 {
3304                         uint32_t _flags_save_string = ndr->flags;
3305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3306                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3307                         ndr->flags = _flags_save_string;
3308                 }
3309                 {
3310                         uint32_t _flags_save_string = ndr->flags;
3311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3312                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3313                         ndr->flags = _flags_save_string;
3314                 }
3315                 {
3316                         uint32_t _flags_save_string = ndr->flags;
3317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3318                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3319                         ndr->flags = _flags_save_string;
3320                 }
3321                 {
3322                         uint32_t _flags_save_string = ndr->flags;
3323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3324                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3325                         ndr->flags = _flags_save_string;
3326                 }
3327                 {
3328                         uint32_t _flags_save_string = ndr->flags;
3329                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3330                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3331                         ndr->flags = _flags_save_string;
3332                 }
3333                 {
3334                         uint32_t _flags_save_string = ndr->flags;
3335                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3336                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3337                         ndr->flags = _flags_save_string;
3338                 }
3339                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3342                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3344                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3345                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3346         }
3347         if (ndr_flags & NDR_BUFFERS) {
3348                 {
3349                         uint32_t _flags_save_string = ndr->flags;
3350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3351                         if (r->printer_name) {
3352                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
3353                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3354                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
3355                         }
3356                         ndr->flags = _flags_save_string;
3357                 }
3358                 {
3359                         uint32_t _flags_save_string = ndr->flags;
3360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3361                         if (r->server_name) {
3362                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
3363                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3364                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
3365                         }
3366                         ndr->flags = _flags_save_string;
3367                 }
3368                 {
3369                         uint32_t _flags_save_string = ndr->flags;
3370                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3371                         if (r->user_name) {
3372                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
3373                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3374                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
3375                         }
3376                         ndr->flags = _flags_save_string;
3377                 }
3378                 {
3379                         uint32_t _flags_save_string = ndr->flags;
3380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3381                         if (r->document_name) {
3382                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
3383                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3384                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
3385                         }
3386                         ndr->flags = _flags_save_string;
3387                 }
3388                 {
3389                         uint32_t _flags_save_string = ndr->flags;
3390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3391                         if (r->data_type) {
3392                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
3393                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3394                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
3395                         }
3396                         ndr->flags = _flags_save_string;
3397                 }
3398                 {
3399                         uint32_t _flags_save_string = ndr->flags;
3400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3401                         if (r->text_status) {
3402                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
3403                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3404                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
3405                         }
3406                         ndr->flags = _flags_save_string;
3407                 }
3408         }
3409         return NDR_ERR_SUCCESS;
3410 }
3411
3412 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
3413 {
3414         uint32_t _ptr_printer_name;
3415         TALLOC_CTX *_mem_save_printer_name_0;
3416         uint32_t _ptr_server_name;
3417         TALLOC_CTX *_mem_save_server_name_0;
3418         uint32_t _ptr_user_name;
3419         TALLOC_CTX *_mem_save_user_name_0;
3420         uint32_t _ptr_document_name;
3421         TALLOC_CTX *_mem_save_document_name_0;
3422         uint32_t _ptr_data_type;
3423         TALLOC_CTX *_mem_save_data_type_0;
3424         uint32_t _ptr_text_status;
3425         TALLOC_CTX *_mem_save_text_status_0;
3426         if (ndr_flags & NDR_SCALARS) {
3427                 NDR_CHECK(ndr_pull_align(ndr, 5));
3428                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3429                 {
3430                         uint32_t _flags_save_string = ndr->flags;
3431                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3432                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3433                         if (_ptr_printer_name) {
3434                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3435                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3436                         } else {
3437                                 r->printer_name = NULL;
3438                         }
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_pull_generic_ptr(ndr, &_ptr_server_name));
3445                         if (_ptr_server_name) {
3446                                 NDR_PULL_ALLOC(ndr, r->server_name);
3447                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3448                         } else {
3449                                 r->server_name = NULL;
3450                         }
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_pull_generic_ptr(ndr, &_ptr_user_name));
3457                         if (_ptr_user_name) {
3458                                 NDR_PULL_ALLOC(ndr, r->user_name);
3459                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3460                         } else {
3461                                 r->user_name = NULL;
3462                         }
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_pull_generic_ptr(ndr, &_ptr_document_name));
3469                         if (_ptr_document_name) {
3470                                 NDR_PULL_ALLOC(ndr, r->document_name);
3471                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3472                         } else {
3473                                 r->document_name = NULL;
3474                         }
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_pull_generic_ptr(ndr, &_ptr_data_type));
3481                         if (_ptr_data_type) {
3482                                 NDR_PULL_ALLOC(ndr, r->data_type);
3483                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3484                         } else {
3485                                 r->data_type = NULL;
3486                         }
3487                         ndr->flags = _flags_save_string;
3488                 }
3489                 {
3490                         uint32_t _flags_save_string = ndr->flags;
3491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3492                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3493                         if (_ptr_text_status) {
3494                                 NDR_PULL_ALLOC(ndr, r->text_status);
3495                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3496                         } else {
3497                                 r->text_status = NULL;
3498                         }
3499                         ndr->flags = _flags_save_string;
3500                 }
3501                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3502                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3503                 if (r->priority > 99) {
3504                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3505                 }
3506                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3507                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3509                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3510                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3511         }
3512         if (ndr_flags & NDR_BUFFERS) {
3513                 {
3514                         uint32_t _flags_save_string = ndr->flags;
3515                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3516                         if (r->printer_name) {
3517                                 uint32_t _relative_save_offset;
3518                                 _relative_save_offset = ndr->offset;
3519                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3520                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3521                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3522                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3523                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3524                                 if (ndr->offset > ndr->relative_highest_offset) {
3525                                         ndr->relative_highest_offset = ndr->offset;
3526                                 }
3527                                 ndr->offset = _relative_save_offset;
3528                         }
3529                         ndr->flags = _flags_save_string;
3530                 }
3531                 {
3532                         uint32_t _flags_save_string = ndr->flags;
3533                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3534                         if (r->server_name) {
3535                                 uint32_t _relative_save_offset;
3536                                 _relative_save_offset = ndr->offset;
3537                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3538                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3539                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3540                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3541                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3542                                 if (ndr->offset > ndr->relative_highest_offset) {
3543                                         ndr->relative_highest_offset = ndr->offset;
3544                                 }
3545                                 ndr->offset = _relative_save_offset;
3546                         }
3547                         ndr->flags = _flags_save_string;
3548                 }
3549                 {
3550                         uint32_t _flags_save_string = ndr->flags;
3551                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3552                         if (r->user_name) {
3553                                 uint32_t _relative_save_offset;
3554                                 _relative_save_offset = ndr->offset;
3555                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3556                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3557                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3558                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3559                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3560                                 if (ndr->offset > ndr->relative_highest_offset) {
3561                                         ndr->relative_highest_offset = ndr->offset;
3562                                 }
3563                                 ndr->offset = _relative_save_offset;
3564                         }
3565                         ndr->flags = _flags_save_string;
3566                 }
3567                 {
3568                         uint32_t _flags_save_string = ndr->flags;
3569                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3570                         if (r->document_name) {
3571                                 uint32_t _relative_save_offset;
3572                                 _relative_save_offset = ndr->offset;
3573                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3574                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3575                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3576                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3577                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3578                                 if (ndr->offset > ndr->relative_highest_offset) {
3579                                         ndr->relative_highest_offset = ndr->offset;
3580                                 }
3581                                 ndr->offset = _relative_save_offset;
3582                         }
3583                         ndr->flags = _flags_save_string;
3584                 }
3585                 {
3586                         uint32_t _flags_save_string = ndr->flags;
3587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3588                         if (r->data_type) {
3589                                 uint32_t _relative_save_offset;
3590                                 _relative_save_offset = ndr->offset;
3591                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3592                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3593                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3594                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3595                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3596                                 if (ndr->offset > ndr->relative_highest_offset) {
3597                                         ndr->relative_highest_offset = ndr->offset;
3598                                 }
3599                                 ndr->offset = _relative_save_offset;
3600                         }
3601                         ndr->flags = _flags_save_string;
3602                 }
3603                 {
3604                         uint32_t _flags_save_string = ndr->flags;
3605                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3606                         if (r->text_status) {
3607                                 uint32_t _relative_save_offset;
3608                                 _relative_save_offset = ndr->offset;
3609                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3610                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3611                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3612                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3613                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3614                                 if (ndr->offset > ndr->relative_highest_offset) {
3615                                         ndr->relative_highest_offset = ndr->offset;
3616                                 }
3617                                 ndr->offset = _relative_save_offset;
3618                         }
3619                         ndr->flags = _flags_save_string;
3620                 }
3621         }
3622         return NDR_ERR_SUCCESS;
3623 }
3624
3625 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
3626 {
3627         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
3628         ndr->depth++;
3629         ndr_print_uint32(ndr, "job_id", r->job_id);
3630         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3631         ndr->depth++;
3632         if (r->printer_name) {
3633                 ndr_print_string(ndr, "printer_name", r->printer_name);
3634         }
3635         ndr->depth--;
3636         ndr_print_ptr(ndr, "server_name", r->server_name);
3637         ndr->depth++;
3638         if (r->server_name) {
3639                 ndr_print_string(ndr, "server_name", r->server_name);
3640         }
3641         ndr->depth--;
3642         ndr_print_ptr(ndr, "user_name", r->user_name);
3643         ndr->depth++;
3644         if (r->user_name) {
3645                 ndr_print_string(ndr, "user_name", r->user_name);
3646         }
3647         ndr->depth--;
3648         ndr_print_ptr(ndr, "document_name", r->document_name);
3649         ndr->depth++;
3650         if (r->document_name) {
3651                 ndr_print_string(ndr, "document_name", r->document_name);
3652         }
3653         ndr->depth--;
3654         ndr_print_ptr(ndr, "data_type", r->data_type);
3655         ndr->depth++;
3656         if (r->data_type) {
3657                 ndr_print_string(ndr, "data_type", r->data_type);
3658         }
3659         ndr->depth--;
3660         ndr_print_ptr(ndr, "text_status", r->text_status);
3661         ndr->depth++;
3662         if (r->text_status) {
3663                 ndr_print_string(ndr, "text_status", r->text_status);
3664         }
3665         ndr->depth--;
3666         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3667         ndr_print_uint32(ndr, "priority", r->priority);
3668         ndr_print_uint32(ndr, "position", r->position);
3669         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3670         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3671         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3672         ndr->depth--;
3673 }
3674
3675 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
3676 {
3677         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
3678 }
3679
3680 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
3681 {
3682         if (ndr_flags & NDR_SCALARS) {
3683                 NDR_CHECK(ndr_push_align(ndr, 5));
3684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3685                 {
3686                         uint32_t _flags_save_string = ndr->flags;
3687                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3688                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3689                         ndr->flags = _flags_save_string;
3690                 }
3691                 {
3692                         uint32_t _flags_save_string = ndr->flags;
3693                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3694                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3695                         ndr->flags = _flags_save_string;
3696                 }
3697                 {
3698                         uint32_t _flags_save_string = ndr->flags;
3699                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3700                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3701                         ndr->flags = _flags_save_string;
3702                 }
3703                 {
3704                         uint32_t _flags_save_string = ndr->flags;
3705                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3706                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3707                         ndr->flags = _flags_save_string;
3708                 }
3709                 {
3710                         uint32_t _flags_save_string = ndr->flags;
3711                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3712                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3713                         ndr->flags = _flags_save_string;
3714                 }
3715                 {
3716                         uint32_t _flags_save_string = ndr->flags;
3717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3718                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3719                         ndr->flags = _flags_save_string;
3720                 }
3721                 {
3722                         uint32_t _flags_save_string = ndr->flags;
3723                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3724                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3725                         ndr->flags = _flags_save_string;
3726                 }
3727                 {
3728                         uint32_t _flags_save_string = ndr->flags;
3729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3730                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3731                         ndr->flags = _flags_save_string;
3732                 }
3733                 {
3734                         uint32_t _flags_save_string = ndr->flags;
3735                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3736                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3737                         ndr->flags = _flags_save_string;
3738                 }
3739                 {
3740                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3741                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3742                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3743                         ndr->flags = _flags_save_spoolss_DeviceMode;
3744                 }
3745                 {
3746                         uint32_t _flags_save_string = ndr->flags;
3747                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3748                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3749                         ndr->flags = _flags_save_string;
3750                 }
3751                 {
3752                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3753                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3754                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3755                         ndr->flags = _flags_save_spoolss_security_descriptor;
3756                 }
3757                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3764                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3767                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3768         }
3769         if (ndr_flags & NDR_BUFFERS) {
3770                 {
3771                         uint32_t _flags_save_string = ndr->flags;
3772                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3773                         if (r->printer_name) {
3774                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
3775                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3776                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
3777                         }
3778                         ndr->flags = _flags_save_string;
3779                 }
3780                 {
3781                         uint32_t _flags_save_string = ndr->flags;
3782                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3783                         if (r->server_name) {
3784                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
3785                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3786                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
3787                         }
3788                         ndr->flags = _flags_save_string;
3789                 }
3790                 {
3791                         uint32_t _flags_save_string = ndr->flags;
3792                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3793                         if (r->user_name) {
3794                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
3795                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3796                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
3797                         }
3798                         ndr->flags = _flags_save_string;
3799                 }
3800                 {
3801                         uint32_t _flags_save_string = ndr->flags;
3802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3803                         if (r->document_name) {
3804                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
3805                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3806                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
3807                         }
3808                         ndr->flags = _flags_save_string;
3809                 }
3810                 {
3811                         uint32_t _flags_save_string = ndr->flags;
3812                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3813                         if (r->notify_name) {
3814                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->notify_name));
3815                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3816                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->notify_name));
3817                         }
3818                         ndr->flags = _flags_save_string;
3819                 }
3820                 {
3821                         uint32_t _flags_save_string = ndr->flags;
3822                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3823                         if (r->data_type) {
3824                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
3825                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3826                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
3827                         }
3828                         ndr->flags = _flags_save_string;
3829                 }
3830                 {
3831                         uint32_t _flags_save_string = ndr->flags;
3832                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3833                         if (r->print_processor) {
3834                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
3835                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3836                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
3837                         }
3838                         ndr->flags = _flags_save_string;
3839                 }
3840                 {
3841                         uint32_t _flags_save_string = ndr->flags;
3842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3843                         if (r->parameters) {
3844                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->parameters));
3845                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3846                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->parameters));
3847                         }
3848                         ndr->flags = _flags_save_string;
3849                 }
3850                 {
3851                         uint32_t _flags_save_string = ndr->flags;
3852                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3853                         if (r->driver_name) {
3854                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
3855                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3856                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
3857                         }
3858                         ndr->flags = _flags_save_string;
3859                 }
3860                 {
3861                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3862                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3863                         if (r->devmode) {
3864                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
3865                                 {
3866                                         struct ndr_push *_ndr_devmode;
3867                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
3868                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3869                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
3870                                 }
3871                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
3872                         }
3873                         ndr->flags = _flags_save_spoolss_DeviceMode;
3874                 }
3875                 {
3876                         uint32_t _flags_save_string = ndr->flags;
3877                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3878                         if (r->text_status) {
3879                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
3880                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3881                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
3882                         }
3883                         ndr->flags = _flags_save_string;
3884                 }
3885                 {
3886                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3888                         if (r->secdesc) {
3889                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
3890                                 {
3891                                         struct ndr_push *_ndr_secdesc;
3892                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
3893                                         NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3894                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
3895                                 }
3896                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
3897                         }
3898                         ndr->flags = _flags_save_spoolss_security_descriptor;
3899                 }
3900         }
3901         return NDR_ERR_SUCCESS;
3902 }
3903
3904 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3905 {
3906         uint32_t _ptr_printer_name;
3907         TALLOC_CTX *_mem_save_printer_name_0;
3908         uint32_t _ptr_server_name;
3909         TALLOC_CTX *_mem_save_server_name_0;
3910         uint32_t _ptr_user_name;
3911         TALLOC_CTX *_mem_save_user_name_0;
3912         uint32_t _ptr_document_name;
3913         TALLOC_CTX *_mem_save_document_name_0;
3914         uint32_t _ptr_notify_name;
3915         TALLOC_CTX *_mem_save_notify_name_0;
3916         uint32_t _ptr_data_type;
3917         TALLOC_CTX *_mem_save_data_type_0;
3918         uint32_t _ptr_print_processor;
3919         TALLOC_CTX *_mem_save_print_processor_0;
3920         uint32_t _ptr_parameters;
3921         TALLOC_CTX *_mem_save_parameters_0;
3922         uint32_t _ptr_driver_name;
3923         TALLOC_CTX *_mem_save_driver_name_0;
3924         uint32_t _ptr_devmode;
3925         TALLOC_CTX *_mem_save_devmode_0;
3926         uint32_t _ptr_text_status;
3927         TALLOC_CTX *_mem_save_text_status_0;
3928         uint32_t _ptr_secdesc;
3929         TALLOC_CTX *_mem_save_secdesc_0;
3930         if (ndr_flags & NDR_SCALARS) {
3931                 NDR_CHECK(ndr_pull_align(ndr, 5));
3932                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3933                 {
3934                         uint32_t _flags_save_string = ndr->flags;
3935                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3936                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3937                         if (_ptr_printer_name) {
3938                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3939                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3940                         } else {
3941                                 r->printer_name = NULL;
3942                         }
3943                         ndr->flags = _flags_save_string;
3944                 }
3945                 {
3946                         uint32_t _flags_save_string = ndr->flags;
3947                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3948                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3949                         if (_ptr_server_name) {
3950                                 NDR_PULL_ALLOC(ndr, r->server_name);
3951                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3952                         } else {
3953                                 r->server_name = NULL;
3954                         }
3955                         ndr->flags = _flags_save_string;
3956                 }
3957                 {
3958                         uint32_t _flags_save_string = ndr->flags;
3959                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3960                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3961                         if (_ptr_user_name) {
3962                                 NDR_PULL_ALLOC(ndr, r->user_name);
3963                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3964                         } else {
3965                                 r->user_name = NULL;
3966                         }
3967                         ndr->flags = _flags_save_string;
3968                 }
3969                 {
3970                         uint32_t _flags_save_string = ndr->flags;
3971                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3972                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3973                         if (_ptr_document_name) {
3974                                 NDR_PULL_ALLOC(ndr, r->document_name);
3975                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3976                         } else {
3977                                 r->document_name = NULL;
3978                         }
3979                         ndr->flags = _flags_save_string;
3980                 }
3981                 {
3982                         uint32_t _flags_save_string = ndr->flags;
3983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3984                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3985                         if (_ptr_notify_name) {
3986                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3987                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3988                         } else {
3989                                 r->notify_name = NULL;
3990                         }
3991                         ndr->flags = _flags_save_string;
3992                 }
3993                 {
3994                         uint32_t _flags_save_string = ndr->flags;
3995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3996                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3997                         if (_ptr_data_type) {
3998                                 NDR_PULL_ALLOC(ndr, r->data_type);
3999                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
4000                         } else {
4001                                 r->data_type = NULL;
4002                         }
4003                         ndr->flags = _flags_save_string;
4004                 }
4005                 {
4006                         uint32_t _flags_save_string = ndr->flags;
4007                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4008                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4009                         if (_ptr_print_processor) {
4010                                 NDR_PULL_ALLOC(ndr, r->print_processor);
4011                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
4012                         } else {
4013                                 r->print_processor = NULL;
4014                         }
4015                         ndr->flags = _flags_save_string;
4016                 }
4017                 {
4018                         uint32_t _flags_save_string = ndr->flags;
4019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4020                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4021                         if (_ptr_parameters) {
4022                                 NDR_PULL_ALLOC(ndr, r->parameters);
4023                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
4024                         } else {
4025                                 r->parameters = NULL;
4026                         }
4027                         ndr->flags = _flags_save_string;
4028                 }
4029                 {
4030                         uint32_t _flags_save_string = ndr->flags;
4031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4032                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4033                         if (_ptr_driver_name) {
4034                                 NDR_PULL_ALLOC(ndr, r->driver_name);
4035                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
4036                         } else {
4037                                 r->driver_name = NULL;
4038                         }
4039                         ndr->flags = _flags_save_string;
4040                 }
4041                 {
4042                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4044                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
4045                         if (_ptr_devmode) {
4046                                 NDR_PULL_ALLOC(ndr, r->devmode);
4047                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
4048                         } else {
4049                                 r->devmode = NULL;
4050                         }
4051                         ndr->flags = _flags_save_spoolss_DeviceMode;
4052                 }
4053                 {
4054                         uint32_t _flags_save_string = ndr->flags;
4055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4056                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4057                         if (_ptr_text_status) {
4058                                 NDR_PULL_ALLOC(ndr, r->text_status);
4059                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
4060                         } else {
4061                                 r->text_status = NULL;
4062                         }
4063                         ndr->flags = _flags_save_string;
4064                 }
4065                 {
4066                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4068                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
4069                         if (_ptr_secdesc) {
4070                                 NDR_PULL_ALLOC(ndr, r->secdesc);
4071                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
4072                         } else {
4073                                 r->secdesc = NULL;
4074                         }
4075                         ndr->flags = _flags_save_spoolss_security_descriptor;
4076                 }
4077                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4078                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4079                 if (r->priority > 99) {
4080                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4081                 }
4082                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4083                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4085                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4086                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4087                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4088                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4089                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4090                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4091         }
4092         if (ndr_flags & NDR_BUFFERS) {
4093                 {
4094                         uint32_t _flags_save_string = ndr->flags;
4095                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4096                         if (r->printer_name) {
4097                                 uint32_t _relative_save_offset;
4098                                 _relative_save_offset = ndr->offset;
4099                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
4100                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4101                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4102                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
4103                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4104                                 if (ndr->offset > ndr->relative_highest_offset) {
4105                                         ndr->relative_highest_offset = ndr->offset;
4106                                 }
4107                                 ndr->offset = _relative_save_offset;
4108                         }
4109                         ndr->flags = _flags_save_string;
4110                 }
4111                 {
4112                         uint32_t _flags_save_string = ndr->flags;
4113                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4114                         if (r->server_name) {
4115                                 uint32_t _relative_save_offset;
4116                                 _relative_save_offset = ndr->offset;
4117                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4118                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4119                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4120                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4121                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4122                                 if (ndr->offset > ndr->relative_highest_offset) {
4123                                         ndr->relative_highest_offset = ndr->offset;
4124                                 }
4125                                 ndr->offset = _relative_save_offset;
4126                         }
4127                         ndr->flags = _flags_save_string;
4128                 }
4129                 {
4130                         uint32_t _flags_save_string = ndr->flags;
4131                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4132                         if (r->user_name) {
4133                                 uint32_t _relative_save_offset;
4134                                 _relative_save_offset = ndr->offset;
4135                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4136                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4137                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4138                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4139                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4140                                 if (ndr->offset > ndr->relative_highest_offset) {
4141                                         ndr->relative_highest_offset = ndr->offset;
4142                                 }
4143                                 ndr->offset = _relative_save_offset;
4144                         }
4145                         ndr->flags = _flags_save_string;
4146                 }
4147                 {
4148                         uint32_t _flags_save_string = ndr->flags;
4149                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4150                         if (r->document_name) {
4151                                 uint32_t _relative_save_offset;
4152                                 _relative_save_offset = ndr->offset;
4153                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4154                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4155                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4156                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4157                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4158                                 if (ndr->offset > ndr->relative_highest_offset) {
4159                                         ndr->relative_highest_offset = ndr->offset;
4160                                 }
4161                                 ndr->offset = _relative_save_offset;
4162                         }
4163                         ndr->flags = _flags_save_string;
4164                 }
4165                 {
4166                         uint32_t _flags_save_string = ndr->flags;
4167                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4168                         if (r->notify_name) {
4169                                 uint32_t _relative_save_offset;
4170                                 _relative_save_offset = ndr->offset;
4171                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4172                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4173                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4174                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4175                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4176                                 if (ndr->offset > ndr->relative_highest_offset) {
4177                                         ndr->relative_highest_offset = ndr->offset;
4178                                 }
4179                                 ndr->offset = _relative_save_offset;
4180                         }
4181                         ndr->flags = _flags_save_string;
4182                 }
4183                 {
4184                         uint32_t _flags_save_string = ndr->flags;
4185                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4186                         if (r->data_type) {
4187                                 uint32_t _relative_save_offset;
4188                                 _relative_save_offset = ndr->offset;
4189                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4190                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4191                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4192                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4193                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4194                                 if (ndr->offset > ndr->relative_highest_offset) {
4195                                         ndr->relative_highest_offset = ndr->offset;
4196                                 }
4197                                 ndr->offset = _relative_save_offset;
4198                         }
4199                         ndr->flags = _flags_save_string;
4200                 }
4201                 {
4202                         uint32_t _flags_save_string = ndr->flags;
4203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4204                         if (r->print_processor) {
4205                                 uint32_t _relative_save_offset;
4206                                 _relative_save_offset = ndr->offset;
4207                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4208                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4209                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4210                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4211                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4212                                 if (ndr->offset > ndr->relative_highest_offset) {
4213                                         ndr->relative_highest_offset = ndr->offset;
4214                                 }
4215                                 ndr->offset = _relative_save_offset;
4216                         }
4217                         ndr->flags = _flags_save_string;
4218                 }
4219                 {
4220                         uint32_t _flags_save_string = ndr->flags;
4221                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4222                         if (r->parameters) {
4223                                 uint32_t _relative_save_offset;
4224                                 _relative_save_offset = ndr->offset;
4225                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4226                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4227                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4228                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4229                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4230                                 if (ndr->offset > ndr->relative_highest_offset) {
4231                                         ndr->relative_highest_offset = ndr->offset;
4232                                 }
4233                                 ndr->offset = _relative_save_offset;
4234                         }
4235                         ndr->flags = _flags_save_string;
4236                 }
4237                 {
4238                         uint32_t _flags_save_string = ndr->flags;
4239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4240                         if (r->driver_name) {
4241                                 uint32_t _relative_save_offset;
4242                                 _relative_save_offset = ndr->offset;
4243                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4244                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4245                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4246                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4247                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4248                                 if (ndr->offset > ndr->relative_highest_offset) {
4249                                         ndr->relative_highest_offset = ndr->offset;
4250                                 }
4251                                 ndr->offset = _relative_save_offset;
4252                         }
4253                         ndr->flags = _flags_save_string;
4254                 }
4255                 {
4256                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4257                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4258                         if (r->devmode) {
4259                                 uint32_t _relative_save_offset;
4260                                 _relative_save_offset = ndr->offset;
4261                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4262                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4263                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4264                                 {
4265                                         struct ndr_pull *_ndr_devmode;
4266                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
4267                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
4268                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
4269                                 }
4270                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4271                                 if (ndr->offset > ndr->relative_highest_offset) {
4272                                         ndr->relative_highest_offset = ndr->offset;
4273                                 }
4274                                 ndr->offset = _relative_save_offset;
4275                         }
4276                         ndr->flags = _flags_save_spoolss_DeviceMode;
4277                 }
4278                 {
4279                         uint32_t _flags_save_string = ndr->flags;
4280                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4281                         if (r->text_status) {
4282                                 uint32_t _relative_save_offset;
4283                                 _relative_save_offset = ndr->offset;
4284                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4285                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4286                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4287                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4288                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4289                                 if (ndr->offset > ndr->relative_highest_offset) {
4290                                         ndr->relative_highest_offset = ndr->offset;
4291                                 }
4292                                 ndr->offset = _relative_save_offset;
4293                         }
4294                         ndr->flags = _flags_save_string;
4295                 }
4296                 {
4297                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4298                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4299                         if (r->secdesc) {
4300                                 uint32_t _relative_save_offset;
4301                                 _relative_save_offset = ndr->offset;
4302                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4303                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4304                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4305                                 {
4306                                         struct ndr_pull *_ndr_secdesc;
4307                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
4308                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4309                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
4310                                 }
4311                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4312                                 if (ndr->offset > ndr->relative_highest_offset) {
4313                                         ndr->relative_highest_offset = ndr->offset;
4314                                 }
4315                                 ndr->offset = _relative_save_offset;
4316                         }
4317                         ndr->flags = _flags_save_spoolss_security_descriptor;
4318                 }
4319         }
4320         return NDR_ERR_SUCCESS;
4321 }
4322
4323 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
4324 {
4325         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
4326         ndr->depth++;
4327         ndr_print_uint32(ndr, "job_id", r->job_id);
4328         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4329         ndr->depth++;
4330         if (r->printer_name) {
4331                 ndr_print_string(ndr, "printer_name", r->printer_name);
4332         }
4333         ndr->depth--;
4334         ndr_print_ptr(ndr, "server_name", r->server_name);
4335         ndr->depth++;
4336         if (r->server_name) {
4337                 ndr_print_string(ndr, "server_name", r->server_name);
4338         }
4339         ndr->depth--;
4340         ndr_print_ptr(ndr, "user_name", r->user_name);
4341         ndr->depth++;
4342         if (r->user_name) {
4343                 ndr_print_string(ndr, "user_name", r->user_name);
4344         }
4345         ndr->depth--;
4346         ndr_print_ptr(ndr, "document_name", r->document_name);
4347         ndr->depth++;
4348         if (r->document_name) {
4349                 ndr_print_string(ndr, "document_name", r->document_name);
4350         }
4351         ndr->depth--;
4352         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4353         ndr->depth++;
4354         if (r->notify_name) {
4355                 ndr_print_string(ndr, "notify_name", r->notify_name);
4356         }
4357         ndr->depth--;
4358         ndr_print_ptr(ndr, "data_type", r->data_type);
4359         ndr->depth++;
4360         if (r->data_type) {
4361                 ndr_print_string(ndr, "data_type", r->data_type);
4362         }
4363         ndr->depth--;
4364         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4365         ndr->depth++;
4366         if (r->print_processor) {
4367                 ndr_print_string(ndr, "print_processor", r->print_processor);
4368         }
4369         ndr->depth--;
4370         ndr_print_ptr(ndr, "parameters", r->parameters);
4371         ndr->depth++;
4372         if (r->parameters) {
4373                 ndr_print_string(ndr, "parameters", r->parameters);
4374         }
4375         ndr->depth--;
4376         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4377         ndr->depth++;
4378         if (r->driver_name) {
4379                 ndr_print_string(ndr, "driver_name", r->driver_name);
4380         }
4381         ndr->depth--;
4382         ndr_print_ptr(ndr, "devmode", r->devmode);
4383         ndr->depth++;
4384         if (r->devmode) {
4385                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4386         }
4387         ndr->depth--;
4388         ndr_print_ptr(ndr, "text_status", r->text_status);
4389         ndr->depth++;
4390         if (r->text_status) {
4391                 ndr_print_string(ndr, "text_status", r->text_status);
4392         }
4393         ndr->depth--;
4394         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4395         ndr->depth++;
4396         if (r->secdesc) {
4397                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
4398         }
4399         ndr->depth--;
4400         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4401         ndr_print_uint32(ndr, "priority", r->priority);
4402         ndr_print_uint32(ndr, "position", r->position);
4403         ndr_print_uint32(ndr, "start_time", r->start_time);
4404         ndr_print_uint32(ndr, "until_time", r->until_time);
4405         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4406         ndr_print_uint32(ndr, "size", r->size);
4407         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4408         ndr_print_uint32(ndr, "time", r->time);
4409         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4410         ndr->depth--;
4411 }
4412
4413 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
4414 {
4415         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
4416 }
4417
4418 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
4419 {
4420         if (ndr_flags & NDR_SCALARS) {
4421                 NDR_CHECK(ndr_push_align(ndr, 4));
4422                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
4424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
4425                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4426         }
4427         if (ndr_flags & NDR_BUFFERS) {
4428         }
4429         return NDR_ERR_SUCCESS;
4430 }
4431
4432 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
4433 {
4434         if (ndr_flags & NDR_SCALARS) {
4435                 NDR_CHECK(ndr_pull_align(ndr, 4));
4436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
4438                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
4439                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4440         }
4441         if (ndr_flags & NDR_BUFFERS) {
4442         }
4443         return NDR_ERR_SUCCESS;
4444 }
4445
4446 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
4447 {
4448         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
4449         ndr->depth++;
4450         ndr_print_uint32(ndr, "job_id", r->job_id);
4451         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
4452         ndr_print_uint32(ndr, "reserved", r->reserved);
4453         ndr->depth--;
4454 }
4455
4456 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
4457 {
4458         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
4459 }
4460
4461 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
4462 {
4463         if (ndr_flags & NDR_SCALARS) {
4464                 NDR_CHECK(ndr_push_align(ndr, 5));
4465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4466                 {
4467                         uint32_t _flags_save_string = ndr->flags;
4468                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4469                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
4470                         ndr->flags = _flags_save_string;
4471                 }
4472                 {
4473                         uint32_t _flags_save_string = ndr->flags;
4474                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4475                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
4476                         ndr->flags = _flags_save_string;
4477                 }
4478                 {
4479                         uint32_t _flags_save_string = ndr->flags;
4480                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4481                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
4482                         ndr->flags = _flags_save_string;
4483                 }
4484                 {
4485                         uint32_t _flags_save_string = ndr->flags;
4486                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4487                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
4494                         ndr->flags = _flags_save_string;
4495                 }
4496                 {
4497                         uint32_t _flags_save_string = ndr->flags;
4498                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4499                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
4500                         ndr->flags = _flags_save_string;
4501                 }
4502                 {
4503                         uint32_t _flags_save_string = ndr->flags;
4504                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4505                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
4506                         ndr->flags = _flags_save_string;
4507                 }
4508                 {
4509                         uint32_t _flags_save_string = ndr->flags;
4510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4511                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
4512                         ndr->flags = _flags_save_string;
4513                 }
4514                 {
4515                         uint32_t _flags_save_string = ndr->flags;
4516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4517                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
4518                         ndr->flags = _flags_save_string;
4519                 }
4520                 {
4521                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4523                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
4524                         ndr->flags = _flags_save_spoolss_DeviceMode;
4525                 }
4526                 {
4527                         uint32_t _flags_save_string = ndr->flags;
4528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4529                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
4530                         ndr->flags = _flags_save_string;
4531                 }
4532                 {
4533                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4535                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
4536                         ndr->flags = _flags_save_spoolss_security_descriptor;
4537                 }
4538                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4545                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4546                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4548                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
4549                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4550         }
4551         if (ndr_flags & NDR_BUFFERS) {
4552                 {
4553                         uint32_t _flags_save_string = ndr->flags;
4554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4555                         if (r->printer_name) {
4556                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
4557                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
4558                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
4559                         }
4560                         ndr->flags = _flags_save_string;
4561                 }
4562                 {
4563                         uint32_t _flags_save_string = ndr->flags;
4564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4565                         if (r->server_name) {
4566                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
4567                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
4568                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
4569                         }
4570                         ndr->flags = _flags_save_string;
4571                 }
4572                 {
4573                         uint32_t _flags_save_string = ndr->flags;
4574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4575                         if (r->user_name) {
4576                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
4577                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
4578                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
4579                         }
4580                         ndr->flags = _flags_save_string;
4581                 }
4582                 {
4583                         uint32_t _flags_save_string = ndr->flags;
4584                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4585                         if (r->document_name) {
4586                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
4587                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
4588                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
4589                         }
4590                         ndr->flags = _flags_save_string;
4591                 }
4592                 {
4593                         uint32_t _flags_save_string = ndr->flags;
4594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4595                         if (r->notify_name) {
4596                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->notify_name));
4597                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
4598                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->notify_name));
4599                         }
4600                         ndr->flags = _flags_save_string;
4601                 }
4602                 {
4603                         uint32_t _flags_save_string = ndr->flags;
4604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4605                         if (r->data_type) {
4606                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
4607                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
4608                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
4609                         }
4610                         ndr->flags = _flags_save_string;
4611                 }
4612                 {
4613                         uint32_t _flags_save_string = ndr->flags;
4614                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4615                         if (r->print_processor) {
4616                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
4617                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
4618                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
4619                         }
4620                         ndr->flags = _flags_save_string;
4621                 }
4622                 {
4623                         uint32_t _flags_save_string = ndr->flags;
4624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4625                         if (r->parameters) {
4626                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->parameters));
4627                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
4628                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->parameters));
4629                         }
4630                         ndr->flags = _flags_save_string;
4631                 }
4632                 {
4633                         uint32_t _flags_save_string = ndr->flags;
4634                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4635                         if (r->driver_name) {
4636                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
4637                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
4638                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
4639                         }
4640                         ndr->flags = _flags_save_string;
4641                 }
4642                 {
4643                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4645                         if (r->devmode) {
4646                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
4647                                 {
4648                                         struct ndr_push *_ndr_devmode;
4649                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
4650                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
4651                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
4652                                 }
4653                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
4654                         }
4655                         ndr->flags = _flags_save_spoolss_DeviceMode;
4656                 }
4657                 {
4658                         uint32_t _flags_save_string = ndr->flags;
4659                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4660                         if (r->text_status) {
4661                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
4662                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
4663                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
4664                         }
4665                         ndr->flags = _flags_save_string;
4666                 }
4667                 {
4668                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4669                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4670                         if (r->secdesc) {
4671                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
4672                                 {
4673                                         struct ndr_push *_ndr_secdesc;
4674                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
4675                                         NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4676                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
4677                                 }
4678                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
4679                         }
4680                         ndr->flags = _flags_save_spoolss_security_descriptor;
4681                 }
4682         }
4683         return NDR_ERR_SUCCESS;
4684 }
4685
4686 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
4687 {
4688         uint32_t _ptr_printer_name;
4689         TALLOC_CTX *_mem_save_printer_name_0;
4690         uint32_t _ptr_server_name;
4691         TALLOC_CTX *_mem_save_server_name_0;
4692         uint32_t _ptr_user_name;
4693         TALLOC_CTX *_mem_save_user_name_0;
4694         uint32_t _ptr_document_name;
4695         TALLOC_CTX *_mem_save_document_name_0;
4696         uint32_t _ptr_notify_name;
4697         TALLOC_CTX *_mem_save_notify_name_0;
4698         uint32_t _ptr_data_type;
4699         TALLOC_CTX *_mem_save_data_type_0;
4700         uint32_t _ptr_print_processor;
4701         TALLOC_CTX *_mem_save_print_processor_0;
4702         uint32_t _ptr_parameters;
4703         TALLOC_CTX *_mem_save_parameters_0;
4704         uint32_t _ptr_driver_name;
4705         TALLOC_CTX *_mem_save_driver_name_0;
4706         uint32_t _ptr_devmode;
4707         TALLOC_CTX *_mem_save_devmode_0;
4708         uint32_t _ptr_text_status;
4709         TALLOC_CTX *_mem_save_text_status_0;
4710         uint32_t _ptr_secdesc;
4711         TALLOC_CTX *_mem_save_secdesc_0;
4712         if (ndr_flags & NDR_SCALARS) {
4713                 NDR_CHECK(ndr_pull_align(ndr, 5));
4714                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4715                 {
4716                         uint32_t _flags_save_string = ndr->flags;
4717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4718                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4719                         if (_ptr_printer_name) {
4720                                 NDR_PULL_ALLOC(ndr, r->printer_name);
4721                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
4722                         } else {
4723                                 r->printer_name = NULL;
4724                         }
4725                         ndr->flags = _flags_save_string;
4726                 }
4727                 {
4728                         uint32_t _flags_save_string = ndr->flags;
4729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4730                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4731                         if (_ptr_server_name) {
4732                                 NDR_PULL_ALLOC(ndr, r->server_name);
4733                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
4734                         } else {
4735                                 r->server_name = NULL;
4736                         }
4737                         ndr->flags = _flags_save_string;
4738                 }
4739                 {
4740                         uint32_t _flags_save_string = ndr->flags;
4741                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4742                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4743                         if (_ptr_user_name) {
4744                                 NDR_PULL_ALLOC(ndr, r->user_name);
4745                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
4746                         } else {
4747                                 r->user_name = NULL;
4748                         }
4749                         ndr->flags = _flags_save_string;
4750                 }
4751                 {
4752                         uint32_t _flags_save_string = ndr->flags;
4753                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4754                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4755                         if (_ptr_document_name) {
4756                                 NDR_PULL_ALLOC(ndr, r->document_name);
4757                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
4758                         } else {
4759                                 r->document_name = NULL;
4760                         }
4761                         ndr->flags = _flags_save_string;
4762                 }
4763                 {
4764                         uint32_t _flags_save_string = ndr->flags;
4765                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4766                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4767                         if (_ptr_notify_name) {
4768                                 NDR_PULL_ALLOC(ndr, r->notify_name);
4769                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
4770                         } else {
4771                                 r->notify_name = NULL;
4772                         }
4773                         ndr->flags = _flags_save_string;
4774                 }
4775                 {
4776                         uint32_t _flags_save_string = ndr->flags;
4777                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4778                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4779                         if (_ptr_data_type) {
4780                                 NDR_PULL_ALLOC(ndr, r->data_type);
4781                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
4782                         } else {
4783                                 r->data_type = NULL;
4784                         }
4785                         ndr->flags = _flags_save_string;
4786                 }
4787                 {
4788                         uint32_t _flags_save_string = ndr->flags;
4789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4790                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4791                         if (_ptr_print_processor) {
4792                                 NDR_PULL_ALLOC(ndr, r->print_processor);
4793                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
4794                         } else {
4795                                 r->print_processor = NULL;
4796                         }
4797                         ndr->flags = _flags_save_string;
4798                 }
4799                 {
4800                         uint32_t _flags_save_string = ndr->flags;
4801                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4802                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4803                         if (_ptr_parameters) {
4804                                 NDR_PULL_ALLOC(ndr, r->parameters);
4805                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
4806                         } else {
4807                                 r->parameters = NULL;
4808                         }
4809                         ndr->flags = _flags_save_string;
4810                 }
4811                 {
4812                         uint32_t _flags_save_string = ndr->flags;
4813                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4814                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4815                         if (_ptr_driver_name) {
4816                                 NDR_PULL_ALLOC(ndr, r->driver_name);
4817                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
4818                         } else {
4819                                 r->driver_name = NULL;
4820                         }
4821                         ndr->flags = _flags_save_string;
4822                 }
4823                 {
4824                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4825                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4826                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
4827                         if (_ptr_devmode) {
4828                                 NDR_PULL_ALLOC(ndr, r->devmode);
4829                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
4830                         } else {
4831                                 r->devmode = NULL;
4832                         }
4833                         ndr->flags = _flags_save_spoolss_DeviceMode;
4834                 }
4835                 {
4836                         uint32_t _flags_save_string = ndr->flags;
4837                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4838                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4839                         if (_ptr_text_status) {
4840                                 NDR_PULL_ALLOC(ndr, r->text_status);
4841                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
4842                         } else {
4843                                 r->text_status = NULL;
4844                         }
4845                         ndr->flags = _flags_save_string;
4846                 }
4847                 {
4848                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4849                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4850                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
4851                         if (_ptr_secdesc) {
4852                                 NDR_PULL_ALLOC(ndr, r->secdesc);
4853                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
4854                         } else {
4855                                 r->secdesc = NULL;
4856                         }
4857                         ndr->flags = _flags_save_spoolss_security_descriptor;
4858                 }
4859                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4861                 if (r->priority > 99) {
4862                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4863                 }
4864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4865                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4866                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4868                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4869                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4870                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
4873                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4874         }
4875         if (ndr_flags & NDR_BUFFERS) {
4876                 {
4877                         uint32_t _flags_save_string = ndr->flags;
4878                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4879                         if (r->printer_name) {
4880                                 uint32_t _relative_save_offset;
4881                                 _relative_save_offset = ndr->offset;
4882                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
4883                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4884                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4885                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
4886                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4887                                 if (ndr->offset > ndr->relative_highest_offset) {
4888                                         ndr->relative_highest_offset = ndr->offset;
4889                                 }
4890                                 ndr->offset = _relative_save_offset;
4891                         }
4892                         ndr->flags = _flags_save_string;
4893                 }
4894                 {
4895                         uint32_t _flags_save_string = ndr->flags;
4896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4897                         if (r->server_name) {
4898                                 uint32_t _relative_save_offset;
4899                                 _relative_save_offset = ndr->offset;
4900                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4901                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4902                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4903                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4904                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4905                                 if (ndr->offset > ndr->relative_highest_offset) {
4906                                         ndr->relative_highest_offset = ndr->offset;
4907                                 }
4908                                 ndr->offset = _relative_save_offset;
4909                         }
4910                         ndr->flags = _flags_save_string;
4911                 }
4912                 {
4913                         uint32_t _flags_save_string = ndr->flags;
4914                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4915                         if (r->user_name) {
4916                                 uint32_t _relative_save_offset;
4917                                 _relative_save_offset = ndr->offset;
4918                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4919                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4920                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4921                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4922                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4923                                 if (ndr->offset > ndr->relative_highest_offset) {
4924                                         ndr->relative_highest_offset = ndr->offset;
4925                                 }
4926                                 ndr->offset = _relative_save_offset;
4927                         }
4928                         ndr->flags = _flags_save_string;
4929                 }
4930                 {
4931                         uint32_t _flags_save_string = ndr->flags;
4932                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4933                         if (r->document_name) {
4934                                 uint32_t _relative_save_offset;
4935                                 _relative_save_offset = ndr->offset;
4936                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4937                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4938                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4939                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4940                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4941                                 if (ndr->offset > ndr->relative_highest_offset) {
4942                                         ndr->relative_highest_offset = ndr->offset;
4943                                 }
4944                                 ndr->offset = _relative_save_offset;
4945                         }
4946                         ndr->flags = _flags_save_string;
4947                 }
4948                 {
4949                         uint32_t _flags_save_string = ndr->flags;
4950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4951                         if (r->notify_name) {
4952                                 uint32_t _relative_save_offset;
4953                                 _relative_save_offset = ndr->offset;
4954                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4955                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4956                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4957                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4958                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4959                                 if (ndr->offset > ndr->relative_highest_offset) {
4960                                         ndr->relative_highest_offset = ndr->offset;
4961                                 }
4962                                 ndr->offset = _relative_save_offset;
4963                         }
4964                         ndr->flags = _flags_save_string;
4965                 }
4966                 {
4967                         uint32_t _flags_save_string = ndr->flags;
4968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4969                         if (r->data_type) {
4970                                 uint32_t _relative_save_offset;
4971                                 _relative_save_offset = ndr->offset;
4972                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4973                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4974                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4975                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4976                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4977                                 if (ndr->offset > ndr->relative_highest_offset) {
4978                                         ndr->relative_highest_offset = ndr->offset;
4979                                 }
4980                                 ndr->offset = _relative_save_offset;
4981                         }
4982                         ndr->flags = _flags_save_string;
4983                 }
4984                 {
4985                         uint32_t _flags_save_string = ndr->flags;
4986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4987                         if (r->print_processor) {
4988                                 uint32_t _relative_save_offset;
4989                                 _relative_save_offset = ndr->offset;
4990                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4991                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4992                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4993                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4994                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4995                                 if (ndr->offset > ndr->relative_highest_offset) {
4996                                         ndr->relative_highest_offset = ndr->offset;
4997                                 }
4998                                 ndr->offset = _relative_save_offset;
4999                         }
5000                         ndr->flags = _flags_save_string;
5001                 }
5002                 {
5003                         uint32_t _flags_save_string = ndr->flags;
5004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5005                         if (r->parameters) {
5006                                 uint32_t _relative_save_offset;
5007                                 _relative_save_offset = ndr->offset;
5008                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
5009                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5010                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5011                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
5012                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5013                                 if (ndr->offset > ndr->relative_highest_offset) {
5014                                         ndr->relative_highest_offset = ndr->offset;
5015                                 }
5016                                 ndr->offset = _relative_save_offset;
5017                         }
5018                         ndr->flags = _flags_save_string;
5019                 }
5020                 {
5021                         uint32_t _flags_save_string = ndr->flags;
5022                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5023                         if (r->driver_name) {
5024                                 uint32_t _relative_save_offset;
5025                                 _relative_save_offset = ndr->offset;
5026                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
5027                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5028                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5029                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
5030                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5031                                 if (ndr->offset > ndr->relative_highest_offset) {
5032                                         ndr->relative_highest_offset = ndr->offset;
5033                                 }
5034                                 ndr->offset = _relative_save_offset;
5035                         }
5036                         ndr->flags = _flags_save_string;
5037                 }
5038                 {
5039                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
5040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
5041                         if (r->devmode) {
5042                                 uint32_t _relative_save_offset;
5043                                 _relative_save_offset = ndr->offset;
5044                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
5045                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
5046                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
5047                                 {
5048                                         struct ndr_pull *_ndr_devmode;
5049                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
5050                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
5051                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
5052                                 }
5053                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
5054                                 if (ndr->offset > ndr->relative_highest_offset) {
5055                                         ndr->relative_highest_offset = ndr->offset;
5056                                 }
5057                                 ndr->offset = _relative_save_offset;
5058                         }
5059                         ndr->flags = _flags_save_spoolss_DeviceMode;
5060                 }
5061                 {
5062                         uint32_t _flags_save_string = ndr->flags;
5063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5064                         if (r->text_status) {
5065                                 uint32_t _relative_save_offset;
5066                                 _relative_save_offset = ndr->offset;
5067                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
5068                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5069                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5070                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
5071                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5072                                 if (ndr->offset > ndr->relative_highest_offset) {
5073                                         ndr->relative_highest_offset = ndr->offset;
5074                                 }
5075                                 ndr->offset = _relative_save_offset;
5076                         }
5077                         ndr->flags = _flags_save_string;
5078                 }
5079                 {
5080                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
5081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
5082                         if (r->secdesc) {
5083                                 uint32_t _relative_save_offset;
5084                                 _relative_save_offset = ndr->offset;
5085                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
5086                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
5087                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
5088                                 {
5089                                         struct ndr_pull *_ndr_secdesc;
5090                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
5091                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
5092                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
5093                                 }
5094                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
5095                                 if (ndr->offset > ndr->relative_highest_offset) {
5096                                         ndr->relative_highest_offset = ndr->offset;
5097                                 }
5098                                 ndr->offset = _relative_save_offset;
5099                         }
5100                         ndr->flags = _flags_save_spoolss_security_descriptor;
5101                 }
5102         }
5103         return NDR_ERR_SUCCESS;
5104 }
5105
5106 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
5107 {
5108         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
5109         ndr->depth++;
5110         ndr_print_uint32(ndr, "job_id", r->job_id);
5111         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5112         ndr->depth++;
5113         if (r->printer_name) {
5114                 ndr_print_string(ndr, "printer_name", r->printer_name);
5115         }
5116         ndr->depth--;
5117         ndr_print_ptr(ndr, "server_name", r->server_name);
5118         ndr->depth++;
5119         if (r->server_name) {
5120                 ndr_print_string(ndr, "server_name", r->server_name);
5121         }
5122         ndr->depth--;
5123         ndr_print_ptr(ndr, "user_name", r->user_name);
5124         ndr->depth++;
5125         if (r->user_name) {
5126                 ndr_print_string(ndr, "user_name", r->user_name);
5127         }
5128         ndr->depth--;
5129         ndr_print_ptr(ndr, "document_name", r->document_name);
5130         ndr->depth++;
5131         if (r->document_name) {
5132                 ndr_print_string(ndr, "document_name", r->document_name);
5133         }
5134         ndr->depth--;
5135         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5136         ndr->depth++;
5137         if (r->notify_name) {
5138                 ndr_print_string(ndr, "notify_name", r->notify_name);
5139         }
5140         ndr->depth--;
5141         ndr_print_ptr(ndr, "data_type", r->data_type);
5142         ndr->depth++;
5143         if (r->data_type) {
5144                 ndr_print_string(ndr, "data_type", r->data_type);
5145         }
5146         ndr->depth--;
5147         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5148         ndr->depth++;
5149         if (r->print_processor) {
5150                 ndr_print_string(ndr, "print_processor", r->print_processor);
5151         }
5152         ndr->depth--;
5153         ndr_print_ptr(ndr, "parameters", r->parameters);
5154         ndr->depth++;
5155         if (r->parameters) {
5156                 ndr_print_string(ndr, "parameters", r->parameters);
5157         }
5158         ndr->depth--;
5159         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5160         ndr->depth++;
5161         if (r->driver_name) {
5162                 ndr_print_string(ndr, "driver_name", r->driver_name);
5163         }
5164         ndr->depth--;
5165         ndr_print_ptr(ndr, "devmode", r->devmode);
5166         ndr->depth++;
5167         if (r->devmode) {
5168                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
5169         }
5170         ndr->depth--;
5171         ndr_print_ptr(ndr, "text_status", r->text_status);
5172         ndr->depth++;
5173         if (r->text_status) {
5174                 ndr_print_string(ndr, "text_status", r->text_status);
5175         }
5176         ndr->depth--;
5177         ndr_print_ptr(ndr, "secdesc", r->secdesc);
5178         ndr->depth++;
5179         if (r->secdesc) {
5180                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
5181         }
5182         ndr->depth--;
5183         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5184         ndr_print_uint32(ndr, "priority", r->priority);
5185         ndr_print_uint32(ndr, "position", r->position);
5186         ndr_print_uint32(ndr, "start_time", r->start_time);
5187         ndr_print_uint32(ndr, "until_time", r->until_time);
5188         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5189         ndr_print_uint32(ndr, "size", r->size);
5190         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5191         ndr_print_uint32(ndr, "time", r->time);
5192         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5193         ndr_print_uint32(ndr, "size_high", r->size_high);
5194         ndr->depth--;
5195 }
5196
5197 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
5198 {
5199         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
5200 }
5201
5202 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
5203 {
5204         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
5205         {
5206                 uint32_t _flags_save_UNION = ndr->flags;
5207                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
5208                 if (ndr_flags & NDR_SCALARS) {
5209                         int level = ndr_push_get_switch_value(ndr, r);
5210                         NDR_CHECK(ndr_push_union_align(ndr, 5));
5211                         switch (level) {
5212                                 case 1: {
5213                                         NDR_CHECK(ndr_push_align(ndr, 5));
5214                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
5215                                         NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
5216                                 break; }
5217
5218                                 case 2: {
5219                                         NDR_CHECK(ndr_push_align(ndr, 5));
5220                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
5221                                         NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
5222                                 break; }
5223
5224                                 case 3: {
5225                                         NDR_CHECK(ndr_push_align(ndr, 4));
5226                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
5227                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
5228                                 break; }
5229
5230                                 case 4: {
5231                                         NDR_CHECK(ndr_push_align(ndr, 5));
5232                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
5233                                         NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
5234                                 break; }
5235
5236                                 default: {
5237                                 break; }
5238
5239                         }
5240                 }
5241                 if (ndr_flags & NDR_BUFFERS) {
5242                         int level = ndr_push_get_switch_value(ndr, r);
5243                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
5244                         switch (level) {
5245                                 case 1:
5246                                         NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
5247                                 break;
5248
5249                                 case 2:
5250                                         NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
5251                                 break;
5252
5253                                 case 3:
5254                                 break;
5255
5256                                 case 4:
5257                                         NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
5258                                 break;
5259
5260                                 default:
5261                                 break;
5262
5263                         }
5264                 }
5265                 ndr->flags = _flags_save_UNION;
5266         }
5267         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
5268         return NDR_ERR_SUCCESS;
5269 }
5270
5271 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
5272 {
5273         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
5274         int level;
5275         {
5276                 uint32_t _flags_save_UNION = ndr->flags;
5277                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
5278                 level = ndr_pull_get_switch_value(ndr, r);
5279                 if (ndr_flags & NDR_SCALARS) {
5280                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
5281                         switch (level) {
5282                                 case 1: {
5283                                         NDR_CHECK(ndr_pull_align(ndr, 5));
5284                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5285                                         NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
5286                                 break; }
5287
5288                                 case 2: {
5289                                         NDR_CHECK(ndr_pull_align(ndr, 5));
5290                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5291                                         NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
5292                                 break; }
5293
5294                                 case 3: {
5295                                         NDR_CHECK(ndr_pull_align(ndr, 4));
5296                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5297                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
5298                                 break; }
5299
5300                                 case 4: {
5301                                         NDR_CHECK(ndr_pull_align(ndr, 5));
5302                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5303                                         NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
5304                                 break; }
5305
5306                                 default: {
5307                                 break; }
5308
5309                         }
5310                 }
5311                 if (ndr_flags & NDR_BUFFERS) {
5312                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
5313                         switch (level) {
5314                                 case 1:
5315                                         NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
5316                                 break;
5317
5318                                 case 2:
5319                                         NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
5320                                 break;
5321
5322                                 case 3:
5323                                 break;
5324
5325                                 case 4:
5326                                         NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
5327                                 break;
5328
5329                                 default:
5330                                 break;
5331
5332                         }
5333                 }
5334                 ndr->flags = _flags_save_UNION;
5335         }
5336         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
5337         return NDR_ERR_SUCCESS;
5338 }
5339
5340 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
5341 {
5342         int level;
5343         {
5344                 uint32_t _flags_save_UNION = ndr->flags;
5345                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
5346                 level = ndr_print_get_switch_value(ndr, r);
5347                 ndr_print_union(ndr, name, level, "spoolss_JobInfo");
5348                 switch (level) {
5349                         case 1:
5350                                 ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
5351                         break;
5352
5353                         case 2:
5354                                 ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
5355                         break;
5356
5357                         case 3:
5358                                 ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
5359                         break;
5360
5361                         case 4:
5362                                 ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
5363                         break;
5364
5365                         default:
5366                         break;
5367
5368                 }
5369                 ndr->flags = _flags_save_UNION;
5370         }
5371 }
5372
5373 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
5374 {
5375         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
5376         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
5377 }
5378
5379 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
5380 {
5381         if (ndr_flags & NDR_SCALARS) {
5382                 NDR_CHECK(ndr_push_align(ndr, 5));
5383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5384                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5385                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5386                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5387                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5388                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5389                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5390                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5395                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5396                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5397         }
5398         if (ndr_flags & NDR_BUFFERS) {
5399                 if (r->printer_name) {
5400                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5401                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5402                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5403                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5404                 }
5405                 if (r->server_name) {
5406                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5407                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5408                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5409                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5410                 }
5411                 if (r->user_name) {
5412                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5413                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5414                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5415                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5416                 }
5417                 if (r->document_name) {
5418                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5419                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5420                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5421                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5422                 }
5423                 if (r->data_type) {
5424                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5425                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5426                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5427                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5428                 }
5429                 if (r->text_status) {
5430                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5431                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5432                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5433                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5434                 }
5435         }
5436         return NDR_ERR_SUCCESS;
5437 }
5438
5439 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
5440 {
5441         uint32_t _ptr_printer_name;
5442         TALLOC_CTX *_mem_save_printer_name_0;
5443         uint32_t _ptr_server_name;
5444         TALLOC_CTX *_mem_save_server_name_0;
5445         uint32_t _ptr_user_name;
5446         TALLOC_CTX *_mem_save_user_name_0;
5447         uint32_t _ptr_document_name;
5448         TALLOC_CTX *_mem_save_document_name_0;
5449         uint32_t _ptr_data_type;
5450         TALLOC_CTX *_mem_save_data_type_0;
5451         uint32_t _ptr_text_status;
5452         TALLOC_CTX *_mem_save_text_status_0;
5453         if (ndr_flags & NDR_SCALARS) {
5454                 NDR_CHECK(ndr_pull_align(ndr, 5));
5455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5456                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5457                 if (_ptr_printer_name) {
5458                         NDR_PULL_ALLOC(ndr, r->printer_name);
5459                 } else {
5460                         r->printer_name = NULL;
5461                 }
5462                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5463                 if (_ptr_server_name) {
5464                         NDR_PULL_ALLOC(ndr, r->server_name);
5465                 } else {
5466                         r->server_name = NULL;
5467                 }
5468                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5469                 if (_ptr_user_name) {
5470                         NDR_PULL_ALLOC(ndr, r->user_name);
5471                 } else {
5472                         r->user_name = NULL;
5473                 }
5474                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5475                 if (_ptr_document_name) {
5476                         NDR_PULL_ALLOC(ndr, r->document_name);
5477                 } else {
5478                         r->document_name = NULL;
5479                 }
5480                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5481                 if (_ptr_data_type) {
5482                         NDR_PULL_ALLOC(ndr, r->data_type);
5483                 } else {
5484                         r->data_type = NULL;
5485                 }
5486                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5487                 if (_ptr_text_status) {
5488                         NDR_PULL_ALLOC(ndr, r->text_status);
5489                 } else {
5490                         r->text_status = NULL;
5491                 }
5492                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5494                 if (r->priority > 99) {
5495                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5496                 }
5497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5498                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5500                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5501                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5502         }
5503         if (ndr_flags & NDR_BUFFERS) {
5504                 if (r->printer_name) {
5505                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5506                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5507                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5508                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5509                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5510                                 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));
5511                         }
5512                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5513                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5514                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5515                 }
5516                 if (r->server_name) {
5517                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5518                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5519                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5520                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5521                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5522                                 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));
5523                         }
5524                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5525                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5526                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5527                 }
5528                 if (r->user_name) {
5529                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5530                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5531                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5532                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5533                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5534                                 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));
5535                         }
5536                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5537                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5538                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5539                 }
5540                 if (r->document_name) {
5541                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5542                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5543                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5544                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5545                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5546                                 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));
5547                         }
5548                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5549                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5550                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5551                 }
5552                 if (r->data_type) {
5553                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5554                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5555                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5556                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5557                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5558                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
5559                         }
5560                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5561                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5562                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5563                 }
5564                 if (r->text_status) {
5565                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5566                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5567                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5568                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5569                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5570                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
5571                         }
5572                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5573                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5574                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5575                 }
5576         }
5577         return NDR_ERR_SUCCESS;
5578 }
5579
5580 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
5581 {
5582         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
5583         ndr->depth++;
5584         ndr_print_uint32(ndr, "job_id", r->job_id);
5585         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5586         ndr->depth++;
5587         if (r->printer_name) {
5588                 ndr_print_string(ndr, "printer_name", r->printer_name);
5589         }
5590         ndr->depth--;
5591         ndr_print_ptr(ndr, "server_name", r->server_name);
5592         ndr->depth++;
5593         if (r->server_name) {
5594                 ndr_print_string(ndr, "server_name", r->server_name);
5595         }
5596         ndr->depth--;
5597         ndr_print_ptr(ndr, "user_name", r->user_name);
5598         ndr->depth++;
5599         if (r->user_name) {
5600                 ndr_print_string(ndr, "user_name", r->user_name);
5601         }
5602         ndr->depth--;
5603         ndr_print_ptr(ndr, "document_name", r->document_name);
5604         ndr->depth++;
5605         if (r->document_name) {
5606                 ndr_print_string(ndr, "document_name", r->document_name);
5607         }
5608         ndr->depth--;
5609         ndr_print_ptr(ndr, "data_type", r->data_type);
5610         ndr->depth++;
5611         if (r->data_type) {
5612                 ndr_print_string(ndr, "data_type", r->data_type);
5613         }
5614         ndr->depth--;
5615         ndr_print_ptr(ndr, "text_status", r->text_status);
5616         ndr->depth++;
5617         if (r->text_status) {
5618                 ndr_print_string(ndr, "text_status", r->text_status);
5619         }
5620         ndr->depth--;
5621         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5622         ndr_print_uint32(ndr, "priority", r->priority);
5623         ndr_print_uint32(ndr, "position", r->position);
5624         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5625         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5626         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5627         ndr->depth--;
5628 }
5629
5630 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
5631 {
5632         if (ndr_flags & NDR_SCALARS) {
5633                 NDR_CHECK(ndr_push_align(ndr, 5));
5634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5635                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5636                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5637                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5638                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5639                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5640                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5641                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5642                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5643                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5645                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5647                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5648                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5650                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5651                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5652                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5654                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5655                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5656                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5657                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5658         }
5659         if (ndr_flags & NDR_BUFFERS) {
5660                 if (r->printer_name) {
5661                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5662                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5663                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5664                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5665                 }
5666                 if (r->server_name) {
5667                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5668                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5669                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5670                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5671                 }
5672                 if (r->user_name) {
5673                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5674                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5675                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5676                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5677                 }
5678                 if (r->document_name) {
5679                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5680                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5681                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5682                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5683                 }
5684                 if (r->notify_name) {
5685                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5686                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5687                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5688                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5689                 }
5690                 if (r->data_type) {
5691                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5692                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5693                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5694                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5695                 }
5696                 if (r->print_processor) {
5697                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5698                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5699                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5700                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5701                 }
5702                 if (r->parameters) {
5703                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5704                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5705                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5706                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5707                 }
5708                 if (r->driver_name) {
5709                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5710                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5711                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5712                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5713                 }
5714                 if (r->text_status) {
5715                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5716                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5717                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5718                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5719                 }
5720         }
5721         return NDR_ERR_SUCCESS;
5722 }
5723
5724 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
5725 {
5726         uint32_t _ptr_printer_name;
5727         TALLOC_CTX *_mem_save_printer_name_0;
5728         uint32_t _ptr_server_name;
5729         TALLOC_CTX *_mem_save_server_name_0;
5730         uint32_t _ptr_user_name;
5731         TALLOC_CTX *_mem_save_user_name_0;
5732         uint32_t _ptr_document_name;
5733         TALLOC_CTX *_mem_save_document_name_0;
5734         uint32_t _ptr_notify_name;
5735         TALLOC_CTX *_mem_save_notify_name_0;
5736         uint32_t _ptr_data_type;
5737         TALLOC_CTX *_mem_save_data_type_0;
5738         uint32_t _ptr_print_processor;
5739         TALLOC_CTX *_mem_save_print_processor_0;
5740         uint32_t _ptr_parameters;
5741         TALLOC_CTX *_mem_save_parameters_0;
5742         uint32_t _ptr_driver_name;
5743         TALLOC_CTX *_mem_save_driver_name_0;
5744         uint32_t _ptr_text_status;
5745         TALLOC_CTX *_mem_save_text_status_0;
5746         if (ndr_flags & NDR_SCALARS) {
5747                 NDR_CHECK(ndr_pull_align(ndr, 5));
5748                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5749                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5750                 if (_ptr_printer_name) {
5751                         NDR_PULL_ALLOC(ndr, r->printer_name);
5752                 } else {
5753                         r->printer_name = NULL;
5754                 }
5755                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5756                 if (_ptr_server_name) {
5757                         NDR_PULL_ALLOC(ndr, r->server_name);
5758                 } else {
5759                         r->server_name = NULL;
5760                 }
5761                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5762                 if (_ptr_user_name) {
5763                         NDR_PULL_ALLOC(ndr, r->user_name);
5764                 } else {
5765                         r->user_name = NULL;
5766                 }
5767                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5768                 if (_ptr_document_name) {
5769                         NDR_PULL_ALLOC(ndr, r->document_name);
5770                 } else {
5771                         r->document_name = NULL;
5772                 }
5773                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5774                 if (_ptr_notify_name) {
5775                         NDR_PULL_ALLOC(ndr, r->notify_name);
5776                 } else {
5777                         r->notify_name = NULL;
5778                 }
5779                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5780                 if (_ptr_data_type) {
5781                         NDR_PULL_ALLOC(ndr, r->data_type);
5782                 } else {
5783                         r->data_type = NULL;
5784                 }
5785                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5786                 if (_ptr_print_processor) {
5787                         NDR_PULL_ALLOC(ndr, r->print_processor);
5788                 } else {
5789                         r->print_processor = NULL;
5790                 }
5791                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5792                 if (_ptr_parameters) {
5793                         NDR_PULL_ALLOC(ndr, r->parameters);
5794                 } else {
5795                         r->parameters = NULL;
5796                 }
5797                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5798                 if (_ptr_driver_name) {
5799                         NDR_PULL_ALLOC(ndr, r->driver_name);
5800                 } else {
5801                         r->driver_name = NULL;
5802                 }
5803                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5804                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5805                 if (_ptr_text_status) {
5806                         NDR_PULL_ALLOC(ndr, r->text_status);
5807                 } else {
5808                         r->text_status = NULL;
5809                 }
5810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5811                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5812                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5813                 if (r->priority > 99) {
5814                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5815                 }
5816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5817                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5818                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5819                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5821                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5822                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5823                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5824                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5825         }
5826         if (ndr_flags & NDR_BUFFERS) {
5827                 if (r->printer_name) {
5828                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5829                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5830                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5831                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5832                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5833                                 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));
5834                         }
5835                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5836                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5837                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5838                 }
5839                 if (r->server_name) {
5840                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5841                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5842                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5843                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5844                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5845                                 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));
5846                         }
5847                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5848                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5849                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5850                 }
5851                 if (r->user_name) {
5852                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5853                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5854                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5855                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5856                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5857                                 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));
5858                         }
5859                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5860                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5861                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5862                 }
5863                 if (r->document_name) {
5864                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5865                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5866                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5867                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5868                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5869                                 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));
5870                         }
5871                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5872                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5873                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5874                 }
5875                 if (r->notify_name) {
5876                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5877                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5878                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5879                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5880                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5881                                 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));
5882                         }
5883                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5884                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5885                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5886                 }
5887                 if (r->data_type) {
5888                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5889                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5890                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5891                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5892                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5893                                 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));
5894                         }
5895                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5896                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5897                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5898                 }
5899                 if (r->print_processor) {
5900                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5901                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5902                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5903                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5904                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5905                                 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));
5906                         }
5907                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5908                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5909                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5910                 }
5911                 if (r->parameters) {
5912                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5913                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5914                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5915                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5916                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5917                                 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));
5918                         }
5919                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5920                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5921                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5922                 }
5923                 if (r->driver_name) {
5924                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5925                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5926                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5927                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5928                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5929                                 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));
5930                         }
5931                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5932                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5933                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5934                 }
5935                 if (r->text_status) {
5936                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5937                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5938                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5939                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5940                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5941                                 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));
5942                         }
5943                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5944                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5945                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5946                 }
5947         }
5948         return NDR_ERR_SUCCESS;
5949 }
5950
5951 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
5952 {
5953         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
5954         ndr->depth++;
5955         ndr_print_uint32(ndr, "job_id", r->job_id);
5956         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5957         ndr->depth++;
5958         if (r->printer_name) {
5959                 ndr_print_string(ndr, "printer_name", r->printer_name);
5960         }
5961         ndr->depth--;
5962         ndr_print_ptr(ndr, "server_name", r->server_name);
5963         ndr->depth++;
5964         if (r->server_name) {
5965                 ndr_print_string(ndr, "server_name", r->server_name);
5966         }
5967         ndr->depth--;
5968         ndr_print_ptr(ndr, "user_name", r->user_name);
5969         ndr->depth++;
5970         if (r->user_name) {
5971                 ndr_print_string(ndr, "user_name", r->user_name);
5972         }
5973         ndr->depth--;
5974         ndr_print_ptr(ndr, "document_name", r->document_name);
5975         ndr->depth++;
5976         if (r->document_name) {
5977                 ndr_print_string(ndr, "document_name", r->document_name);
5978         }
5979         ndr->depth--;
5980         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5981         ndr->depth++;
5982         if (r->notify_name) {
5983                 ndr_print_string(ndr, "notify_name", r->notify_name);
5984         }
5985         ndr->depth--;
5986         ndr_print_ptr(ndr, "data_type", r->data_type);
5987         ndr->depth++;
5988         if (r->data_type) {
5989                 ndr_print_string(ndr, "data_type", r->data_type);
5990         }
5991         ndr->depth--;
5992         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5993         ndr->depth++;
5994         if (r->print_processor) {
5995                 ndr_print_string(ndr, "print_processor", r->print_processor);
5996         }
5997         ndr->depth--;
5998         ndr_print_ptr(ndr, "parameters", r->parameters);
5999         ndr->depth++;
6000         if (r->parameters) {
6001                 ndr_print_string(ndr, "parameters", r->parameters);
6002         }
6003         ndr->depth--;
6004         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6005         ndr->depth++;
6006         if (r->driver_name) {
6007                 ndr_print_string(ndr, "driver_name", r->driver_name);
6008         }
6009         ndr->depth--;
6010         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
6011         ndr_print_ptr(ndr, "text_status", r->text_status);
6012         ndr->depth++;
6013         if (r->text_status) {
6014                 ndr_print_string(ndr, "text_status", r->text_status);
6015         }
6016         ndr->depth--;
6017         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
6018         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
6019         ndr_print_uint32(ndr, "priority", r->priority);
6020         ndr_print_uint32(ndr, "position", r->position);
6021         ndr_print_uint32(ndr, "start_time", r->start_time);
6022         ndr_print_uint32(ndr, "until_time", r->until_time);
6023         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6024         ndr_print_uint32(ndr, "size", r->size);
6025         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
6026         ndr_print_uint32(ndr, "time", r->time);
6027         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
6028         ndr->depth--;
6029 }
6030
6031 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
6032 {
6033         if (ndr_flags & NDR_SCALARS) {
6034                 NDR_CHECK(ndr_push_align(ndr, 5));
6035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
6036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
6037                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
6038                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
6039                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
6040                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
6041                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
6042                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
6043                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6044                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
6045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
6046                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
6047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
6048                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
6049                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6050                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
6051                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
6052                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
6053                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
6054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
6055                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
6056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
6057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
6058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
6059                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6060         }
6061         if (ndr_flags & NDR_BUFFERS) {
6062                 if (r->printer_name) {
6063                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
6064                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6065                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
6066                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6067                 }
6068                 if (r->server_name) {
6069                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6070                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6071                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6072                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6073                 }
6074                 if (r->user_name) {
6075                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
6076                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6077                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
6078                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6079                 }
6080                 if (r->document_name) {
6081                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
6082                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6083                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
6084                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6085                 }
6086                 if (r->notify_name) {
6087                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
6088                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6089                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
6090                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6091                 }
6092                 if (r->data_type) {
6093                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
6094                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6095                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
6096                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6097                 }
6098                 if (r->print_processor) {
6099                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
6100                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6101                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
6102                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6103                 }
6104                 if (r->parameters) {
6105                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6106                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6107                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6108                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6109                 }
6110                 if (r->driver_name) {
6111                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6112                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6113                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6114                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6115                 }
6116                 if (r->text_status) {
6117                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
6118                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6119                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
6120                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6121                 }
6122         }
6123         return NDR_ERR_SUCCESS;
6124 }
6125
6126 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
6127 {
6128         uint32_t _ptr_printer_name;
6129         TALLOC_CTX *_mem_save_printer_name_0;
6130         uint32_t _ptr_server_name;
6131         TALLOC_CTX *_mem_save_server_name_0;
6132         uint32_t _ptr_user_name;
6133         TALLOC_CTX *_mem_save_user_name_0;
6134         uint32_t _ptr_document_name;
6135         TALLOC_CTX *_mem_save_document_name_0;
6136         uint32_t _ptr_notify_name;
6137         TALLOC_CTX *_mem_save_notify_name_0;
6138         uint32_t _ptr_data_type;
6139         TALLOC_CTX *_mem_save_data_type_0;
6140         uint32_t _ptr_print_processor;
6141         TALLOC_CTX *_mem_save_print_processor_0;
6142         uint32_t _ptr_parameters;
6143         TALLOC_CTX *_mem_save_parameters_0;
6144         uint32_t _ptr_driver_name;
6145         TALLOC_CTX *_mem_save_driver_name_0;
6146         uint32_t _ptr_text_status;
6147         TALLOC_CTX *_mem_save_text_status_0;
6148         if (ndr_flags & NDR_SCALARS) {
6149                 NDR_CHECK(ndr_pull_align(ndr, 5));
6150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
6151                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
6152                 if (_ptr_printer_name) {
6153                         NDR_PULL_ALLOC(ndr, r->printer_name);
6154                 } else {
6155                         r->printer_name = NULL;
6156                 }
6157                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6158                 if (_ptr_server_name) {
6159                         NDR_PULL_ALLOC(ndr, r->server_name);
6160                 } else {
6161                         r->server_name = NULL;
6162                 }
6163                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
6164                 if (_ptr_user_name) {
6165                         NDR_PULL_ALLOC(ndr, r->user_name);
6166                 } else {
6167                         r->user_name = NULL;
6168                 }
6169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
6170                 if (_ptr_document_name) {
6171                         NDR_PULL_ALLOC(ndr, r->document_name);
6172                 } else {
6173                         r->document_name = NULL;
6174                 }
6175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
6176                 if (_ptr_notify_name) {
6177                         NDR_PULL_ALLOC(ndr, r->notify_name);
6178                 } else {
6179                         r->notify_name = NULL;
6180                 }
6181                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
6182                 if (_ptr_data_type) {
6183                         NDR_PULL_ALLOC(ndr, r->data_type);
6184                 } else {
6185                         r->data_type = NULL;
6186                 }
6187                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
6188                 if (_ptr_print_processor) {
6189                         NDR_PULL_ALLOC(ndr, r->print_processor);
6190                 } else {
6191                         r->print_processor = NULL;
6192                 }
6193                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6194                 if (_ptr_parameters) {
6195                         NDR_PULL_ALLOC(ndr, r->parameters);
6196                 } else {
6197                         r->parameters = NULL;
6198                 }
6199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
6200                 if (_ptr_driver_name) {
6201                         NDR_PULL_ALLOC(ndr, r->driver_name);
6202                 } else {
6203                         r->driver_name = NULL;
6204                 }
6205                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
6206                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
6207                 if (_ptr_text_status) {
6208                         NDR_PULL_ALLOC(ndr, r->text_status);
6209                 } else {
6210                         r->text_status = NULL;
6211                 }
6212                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
6213                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
6214                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6215                 if (r->priority > 99) {
6216                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6217                 }
6218                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
6219                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
6220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
6221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
6222                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
6223                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
6224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
6225                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
6226                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
6227                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6228         }
6229         if (ndr_flags & NDR_BUFFERS) {
6230                 if (r->printer_name) {
6231                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6232                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
6233                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
6234                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
6235                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
6236                                 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));
6237                         }
6238                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
6239                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
6240                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
6241                 }
6242                 if (r->server_name) {
6243                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6244                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
6245                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
6246                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
6247                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
6248                                 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));
6249                         }
6250                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
6251                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
6252                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6253                 }
6254                 if (r->user_name) {
6255                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6256                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
6257                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
6258                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
6259                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
6260                                 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));
6261                         }
6262                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
6263                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
6264                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
6265                 }
6266                 if (r->document_name) {
6267                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6268                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
6269                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
6270                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
6271                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
6272                                 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));
6273                         }
6274                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
6275                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
6276                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
6277                 }
6278                 if (r->notify_name) {
6279                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6280                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
6281                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
6282                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
6283                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
6284                                 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));
6285                         }
6286                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
6287                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
6288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
6289                 }
6290                 if (r->data_type) {
6291                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
6292                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
6293                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
6294                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
6295                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
6296                                 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));
6297                         }
6298                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
6299                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
6300                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
6301                 }
6302                 if (r->print_processor) {
6303                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6304                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
6305                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
6306                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
6307                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
6308                                 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));
6309                         }
6310                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
6311                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
6312                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
6313                 }
6314                 if (r->parameters) {
6315                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6316                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6317                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6318                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6319                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6320                                 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));
6321                         }
6322                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6323                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6324                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6325                 }
6326                 if (r->driver_name) {
6327                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6328                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6329                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
6330                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
6331                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
6332                                 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));
6333                         }
6334                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
6335                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
6336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6337                 }
6338                 if (r->text_status) {
6339                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
6340                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
6341                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
6342                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
6343                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
6344                                 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));
6345                         }
6346                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
6347                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
6348                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
6349                 }
6350         }
6351         return NDR_ERR_SUCCESS;
6352 }
6353
6354 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
6355 {
6356         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
6357         ndr->depth++;
6358         ndr_print_uint32(ndr, "job_id", r->job_id);
6359         ndr_print_ptr(ndr, "printer_name", r->printer_name);
6360         ndr->depth++;
6361         if (r->printer_name) {
6362                 ndr_print_string(ndr, "printer_name", r->printer_name);
6363         }
6364         ndr->depth--;
6365         ndr_print_ptr(ndr, "server_name", r->server_name);
6366         ndr->depth++;
6367         if (r->server_name) {
6368                 ndr_print_string(ndr, "server_name", r->server_name);
6369         }
6370         ndr->depth--;
6371         ndr_print_ptr(ndr, "user_name", r->user_name);
6372         ndr->depth++;
6373         if (r->user_name) {
6374                 ndr_print_string(ndr, "user_name", r->user_name);
6375         }
6376         ndr->depth--;
6377         ndr_print_ptr(ndr, "document_name", r->document_name);
6378         ndr->depth++;
6379         if (r->document_name) {
6380                 ndr_print_string(ndr, "document_name", r->document_name);
6381         }
6382         ndr->depth--;
6383         ndr_print_ptr(ndr, "notify_name", r->notify_name);
6384         ndr->depth++;
6385         if (r->notify_name) {
6386                 ndr_print_string(ndr, "notify_name", r->notify_name);
6387         }
6388         ndr->depth--;
6389         ndr_print_ptr(ndr, "data_type", r->data_type);
6390         ndr->depth++;
6391         if (r->data_type) {
6392                 ndr_print_string(ndr, "data_type", r->data_type);
6393         }
6394         ndr->depth--;
6395         ndr_print_ptr(ndr, "print_processor", r->print_processor);
6396         ndr->depth++;
6397         if (r->print_processor) {
6398                 ndr_print_string(ndr, "print_processor", r->print_processor);
6399         }
6400         ndr->depth--;
6401         ndr_print_ptr(ndr, "parameters", r->parameters);
6402         ndr->depth++;
6403         if (r->parameters) {
6404                 ndr_print_string(ndr, "parameters", r->parameters);
6405         }
6406         ndr->depth--;
6407         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6408         ndr->depth++;
6409         if (r->driver_name) {
6410                 ndr_print_string(ndr, "driver_name", r->driver_name);
6411         }
6412         ndr->depth--;
6413         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
6414         ndr_print_ptr(ndr, "text_status", r->text_status);
6415         ndr->depth++;
6416         if (r->text_status) {
6417                 ndr_print_string(ndr, "text_status", r->text_status);
6418         }
6419         ndr->depth--;
6420         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
6421         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
6422         ndr_print_uint32(ndr, "priority", r->priority);
6423         ndr_print_uint32(ndr, "position", r->position);
6424         ndr_print_uint32(ndr, "start_time", r->start_time);
6425         ndr_print_uint32(ndr, "until_time", r->until_time);
6426         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6427         ndr_print_uint32(ndr, "size", r->size);
6428         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
6429         ndr_print_uint32(ndr, "time", r->time);
6430         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
6431         ndr_print_uint32(ndr, "size_high", r->size_high);
6432         ndr->depth--;
6433 }
6434
6435 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
6436 {
6437         if (ndr_flags & NDR_SCALARS) {
6438                 int level = ndr_push_get_switch_value(ndr, r);
6439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6440                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6441                 switch (level) {
6442                         case 1: {
6443                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6444                         break; }
6445
6446                         case 2: {
6447                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6448                         break; }
6449
6450                         case 3: {
6451                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6452                         break; }
6453
6454                         case 4: {
6455                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6456                         break; }
6457
6458                         default: {
6459                         break; }
6460
6461                 }
6462         }
6463         if (ndr_flags & NDR_BUFFERS) {
6464                 int level = ndr_push_get_switch_value(ndr, r);
6465                 switch (level) {
6466                         case 1:
6467                                 if (r->info1) {
6468                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6469                                 }
6470                         break;
6471
6472                         case 2:
6473                                 if (r->info2) {
6474                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6475                                 }
6476                         break;
6477
6478                         case 3:
6479                                 if (r->info3) {
6480                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6481                                 }
6482                         break;
6483
6484                         case 4:
6485                                 if (r->info4) {
6486                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6487                                 }
6488                         break;
6489
6490                         default:
6491                         break;
6492
6493                 }
6494         }
6495         return NDR_ERR_SUCCESS;
6496 }
6497
6498 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
6499 {
6500         int level;
6501         uint32_t _level;
6502         TALLOC_CTX *_mem_save_info1_0;
6503         TALLOC_CTX *_mem_save_info2_0;
6504         TALLOC_CTX *_mem_save_info3_0;
6505         TALLOC_CTX *_mem_save_info4_0;
6506         level = ndr_pull_get_switch_value(ndr, r);
6507         if (ndr_flags & NDR_SCALARS) {
6508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6509                 if (_level != level) {
6510                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6511                 }
6512                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6513                 switch (level) {
6514                         case 1: {
6515                                 uint32_t _ptr_info1;
6516                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6517                                 if (_ptr_info1) {
6518                                         NDR_PULL_ALLOC(ndr, r->info1);
6519                                 } else {
6520                                         r->info1 = NULL;
6521                                 }
6522                         break; }
6523
6524                         case 2: {
6525                                 uint32_t _ptr_info2;
6526                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6527                                 if (_ptr_info2) {
6528                                         NDR_PULL_ALLOC(ndr, r->info2);
6529                                 } else {
6530                                         r->info2 = NULL;
6531                                 }
6532                         break; }
6533
6534                         case 3: {
6535                                 uint32_t _ptr_info3;
6536                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6537                                 if (_ptr_info3) {
6538                                         NDR_PULL_ALLOC(ndr, r->info3);
6539                                 } else {
6540                                         r->info3 = NULL;
6541                                 }
6542                         break; }
6543
6544                         case 4: {
6545                                 uint32_t _ptr_info4;
6546                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6547                                 if (_ptr_info4) {
6548                                         NDR_PULL_ALLOC(ndr, r->info4);
6549                                 } else {
6550                                         r->info4 = NULL;
6551                                 }
6552                         break; }
6553
6554                         default: {
6555                         break; }
6556
6557                 }
6558         }
6559         if (ndr_flags & NDR_BUFFERS) {
6560                 switch (level) {
6561                         case 1:
6562                                 if (r->info1) {
6563                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6564                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6565                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6566                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6567                                 }
6568                         break;
6569
6570                         case 2:
6571                                 if (r->info2) {
6572                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6573                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
6574                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6575                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
6576                                 }
6577                         break;
6578
6579                         case 3:
6580                                 if (r->info3) {
6581                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
6582                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
6583                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6584                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
6585                                 }
6586                         break;
6587
6588                         case 4:
6589                                 if (r->info4) {
6590                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
6591                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
6592                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6593                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
6594                                 }
6595                         break;
6596
6597                         default:
6598                         break;
6599
6600                 }
6601         }
6602         return NDR_ERR_SUCCESS;
6603 }
6604
6605 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
6606 {
6607         int level;
6608         level = ndr_print_get_switch_value(ndr, r);
6609         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
6610         switch (level) {
6611                 case 1:
6612                         ndr_print_ptr(ndr, "info1", r->info1);
6613                         ndr->depth++;
6614                         if (r->info1) {
6615                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
6616                         }
6617                         ndr->depth--;
6618                 break;
6619
6620                 case 2:
6621                         ndr_print_ptr(ndr, "info2", r->info2);
6622                         ndr->depth++;
6623                         if (r->info2) {
6624                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
6625                         }
6626                         ndr->depth--;
6627                 break;
6628
6629                 case 3:
6630                         ndr_print_ptr(ndr, "info3", r->info3);
6631                         ndr->depth++;
6632                         if (r->info3) {
6633                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
6634                         }
6635                         ndr->depth--;
6636                 break;
6637
6638                 case 4:
6639                         ndr_print_ptr(ndr, "info4", r->info4);
6640                         ndr->depth++;
6641                         if (r->info4) {
6642                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
6643                         }
6644                         ndr->depth--;
6645                 break;
6646
6647                 default:
6648                 break;
6649
6650         }
6651 }
6652
6653 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
6654 {
6655         if (ndr_flags & NDR_SCALARS) {
6656                 NDR_CHECK(ndr_push_align(ndr, 5));
6657                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
6658                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
6659                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6660                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6661         }
6662         if (ndr_flags & NDR_BUFFERS) {
6663                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6664         }
6665         return NDR_ERR_SUCCESS;
6666 }
6667
6668 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
6669 {
6670         if (ndr_flags & NDR_SCALARS) {
6671                 NDR_CHECK(ndr_pull_align(ndr, 5));
6672                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
6673                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
6674                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6675                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6676         }
6677         if (ndr_flags & NDR_BUFFERS) {
6678                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6679         }
6680         return NDR_ERR_SUCCESS;
6681 }
6682
6683 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
6684 {
6685         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
6686         ndr->depth++;
6687         ndr_print_uint32(ndr, "level", r->level);
6688         ndr_print_set_switch_value(ndr, &r->info, r->level);
6689         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
6690         ndr->depth--;
6691 }
6692
6693 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
6694 {
6695         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6696         return NDR_ERR_SUCCESS;
6697 }
6698
6699 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
6700 {
6701         uint32_t v;
6702         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6703         *r = v;
6704         return NDR_ERR_SUCCESS;
6705 }
6706
6707 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
6708 {
6709         const char *val = NULL;
6710
6711         switch (r) {
6712                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
6713                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
6714                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
6715                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
6716                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
6717                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
6718                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
6719                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
6720                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
6721         }
6722         ndr_print_enum(ndr, name, "ENUM", val, r);
6723 }
6724
6725 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
6726 {
6727         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6728         return NDR_ERR_SUCCESS;
6729 }
6730
6731 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
6732 {
6733         uint32_t v;
6734         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6735         *r = v;
6736         return NDR_ERR_SUCCESS;
6737 }
6738
6739 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
6740 {
6741         const char *val = NULL;
6742
6743         switch (r) {
6744                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
6745                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
6746                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
6747                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
6748                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
6749         }
6750         ndr_print_enum(ndr, name, "ENUM", val, r);
6751 }
6752
6753 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
6754 {
6755         if (ndr_flags & NDR_SCALARS) {
6756                 NDR_CHECK(ndr_push_align(ndr, 5));
6757                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6758                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
6761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
6762                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
6764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
6765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
6766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
6767                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
6768                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
6769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
6770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
6771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
6772                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
6773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
6774                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
6775                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
6776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
6777                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
6778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
6779                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
6780                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
6781                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
6782                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
6783                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
6784                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
6785                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
6786                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6787         }
6788         if (ndr_flags & NDR_BUFFERS) {
6789                 if (r->servername) {
6790                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6791                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6792                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6793                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6794                 }
6795                 if (r->printername) {
6796                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6797                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6798                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6799                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6800                 }
6801         }
6802         return NDR_ERR_SUCCESS;
6803 }
6804
6805 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
6806 {
6807         uint32_t _ptr_servername;
6808         TALLOC_CTX *_mem_save_servername_0;
6809         uint32_t _ptr_printername;
6810         TALLOC_CTX *_mem_save_printername_0;
6811         if (ndr_flags & NDR_SCALARS) {
6812                 NDR_CHECK(ndr_pull_align(ndr, 5));
6813                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6814                 if (_ptr_servername) {
6815                         NDR_PULL_ALLOC(ndr, r->servername);
6816                 } else {
6817                         r->servername = NULL;
6818                 }
6819                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6820                 if (_ptr_printername) {
6821                         NDR_PULL_ALLOC(ndr, r->printername);
6822                 } else {
6823                         r->printername = NULL;
6824                 }
6825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6826                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
6827                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
6828                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6829                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
6830                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
6831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
6832                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
6833                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
6834                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
6835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
6836                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
6837                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
6838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
6839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
6840                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
6841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
6842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
6843                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
6844                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
6845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
6846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
6847                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
6848                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
6849                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
6850                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
6851                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
6852                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6853         }
6854         if (ndr_flags & NDR_BUFFERS) {
6855                 if (r->servername) {
6856                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6857                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6858                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6859                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6860                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6861                                 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));
6862                         }
6863                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6864                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6865                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6866                 }
6867                 if (r->printername) {
6868                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6869                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6870                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6871                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6872                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6873                                 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));
6874                         }
6875                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6876                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6877                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6878                 }
6879         }
6880         return NDR_ERR_SUCCESS;
6881 }
6882
6883 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
6884 {
6885         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
6886         ndr->depth++;
6887         ndr_print_ptr(ndr, "servername", r->servername);
6888         ndr->depth++;
6889         if (r->servername) {
6890                 ndr_print_string(ndr, "servername", r->servername);
6891         }
6892         ndr->depth--;
6893         ndr_print_ptr(ndr, "printername", r->printername);
6894         ndr->depth++;
6895         if (r->printername) {
6896                 ndr_print_string(ndr, "printername", r->printername);
6897         }
6898         ndr->depth--;
6899         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6900         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
6901         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
6902         ndr_print_spoolss_Time(ndr, "time", &r->time);
6903         ndr_print_uint32(ndr, "global_counter", r->global_counter);
6904         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6905         ndr_print_uint32(ndr, "version", r->version);
6906         ndr_print_uint32(ndr, "free_build", r->free_build);
6907         ndr_print_uint32(ndr, "spooling", r->spooling);
6908         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
6909         ndr_print_uint32(ndr, "session_counter", r->session_counter);
6910         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
6911         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
6912         ndr_print_uint32(ndr, "job_error", r->job_error);
6913         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
6914         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
6915         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
6916         ndr_print_uint32(ndr, "change_id", r->change_id);
6917         ndr_print_WERROR(ndr, "last_error", r->last_error);
6918         ndr_print_uint32(ndr, "status", r->status);
6919         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
6920         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
6921         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
6922         ndr_print_uint16(ndr, "processor_level", r->processor_level);
6923         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
6924         ndr_print_uint32(ndr, "reserved2", r->reserved2);
6925         ndr_print_uint32(ndr, "reserved3", r->reserved3);
6926         ndr->depth--;
6927 }
6928
6929 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
6930 {
6931         if (ndr_flags & NDR_SCALARS) {
6932                 NDR_CHECK(ndr_push_align(ndr, 5));
6933                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
6934                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
6935                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
6936                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6937                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6938         }
6939         if (ndr_flags & NDR_BUFFERS) {
6940                 if (r->description) {
6941                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6942                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6943                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6944                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6945                 }
6946                 if (r->name) {
6947                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6948                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6949                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6950                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6951                 }
6952                 if (r->comment) {
6953                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6954                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6955                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6956                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6957                 }
6958         }
6959         return NDR_ERR_SUCCESS;
6960 }
6961
6962 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
6963 {
6964         uint32_t _ptr_description;
6965         TALLOC_CTX *_mem_save_description_0;
6966         uint32_t _ptr_name;
6967         TALLOC_CTX *_mem_save_name_0;
6968         uint32_t _ptr_comment;
6969         TALLOC_CTX *_mem_save_comment_0;
6970         if (ndr_flags & NDR_SCALARS) {
6971                 NDR_CHECK(ndr_pull_align(ndr, 5));
6972                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
6973                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
6974                 if (_ptr_description) {
6975                         NDR_PULL_ALLOC(ndr, r->description);
6976                 } else {
6977                         r->description = NULL;
6978                 }
6979                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
6980                 if (_ptr_name) {
6981                         NDR_PULL_ALLOC(ndr, r->name);
6982                 } else {
6983                         r->name = NULL;
6984                 }
6985                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6986                 if (_ptr_comment) {
6987                         NDR_PULL_ALLOC(ndr, r->comment);
6988                 } else {
6989                         r->comment = NULL;
6990                 }
6991                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6992         }
6993         if (ndr_flags & NDR_BUFFERS) {
6994                 if (r->description) {
6995                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
6996                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
6997                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
6998                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
6999                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
7000                                 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));
7001                         }
7002                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
7003                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
7004                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
7005                 }
7006                 if (r->name) {
7007                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7008                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
7009                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
7010                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
7011                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
7012                                 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));
7013                         }
7014                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
7015                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
7016                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
7017                 }
7018                 if (r->comment) {
7019                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
7020                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
7021                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
7022                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
7023                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
7024                                 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));
7025                         }
7026                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
7027                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
7028                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
7029                 }
7030         }
7031         return NDR_ERR_SUCCESS;
7032 }
7033
7034 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
7035 {
7036         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
7037         ndr->depth++;
7038         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
7039         ndr_print_ptr(ndr, "description", r->description);
7040         ndr->depth++;
7041         if (r->description) {
7042                 ndr_print_string(ndr, "description", r->description);
7043         }
7044         ndr->depth--;
7045         ndr_print_ptr(ndr, "name", r->name);
7046         ndr->depth++;
7047         if (r->name) {
7048                 ndr_print_string(ndr, "name", r->name);
7049         }
7050         ndr->depth--;
7051         ndr_print_ptr(ndr, "comment", r->comment);
7052         ndr->depth++;
7053         if (r->comment) {
7054                 ndr_print_string(ndr, "comment", r->comment);
7055         }
7056         ndr->depth--;
7057         ndr->depth--;
7058 }
7059
7060 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
7061 {
7062         if (ndr_flags & NDR_SCALARS) {
7063                 NDR_CHECK(ndr_push_align(ndr, 5));
7064                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
7065                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7066                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
7067                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
7068                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
7069                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
7070                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
7071                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
7072                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
7073                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
7074                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
7075                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
7076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->secdesc_ptr));
7077                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
7079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
7080                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
7081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
7082                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
7083                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
7084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
7085                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7086         }
7087         if (ndr_flags & NDR_BUFFERS) {
7088                 if (r->servername) {
7089                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7090                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7091                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7092                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7093                 }
7094                 if (r->printername) {
7095                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7096                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7097                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7098                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7099                 }
7100                 if (r->sharename) {
7101                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
7102                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7103                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
7104                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7105                 }
7106                 if (r->portname) {
7107                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7108                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7109                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7110                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7111                 }
7112                 if (r->drivername) {
7113                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
7114                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7115                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
7116                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7117                 }
7118                 if (r->comment) {
7119                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
7120                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7121                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
7122                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7123                 }
7124                 if (r->location) {
7125                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
7126                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7127                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
7128                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7129                 }
7130                 if (r->sepfile) {
7131                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
7132                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7133                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
7134                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7135                 }
7136                 if (r->printprocessor) {
7137                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
7138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7139                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
7140                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7141                 }
7142                 if (r->datatype) {
7143                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
7144                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7145                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
7146                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7147                 }
7148                 if (r->parameters) {
7149                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
7150                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7151                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
7152                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7153                 }
7154         }
7155         return NDR_ERR_SUCCESS;
7156 }
7157
7158 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
7159 {
7160         uint32_t _ptr_servername;
7161         TALLOC_CTX *_mem_save_servername_0;
7162         uint32_t _ptr_printername;
7163         TALLOC_CTX *_mem_save_printername_0;
7164         uint32_t _ptr_sharename;
7165         TALLOC_CTX *_mem_save_sharename_0;
7166         uint32_t _ptr_portname;
7167         TALLOC_CTX *_mem_save_portname_0;
7168         uint32_t _ptr_drivername;
7169         TALLOC_CTX *_mem_save_drivername_0;
7170         uint32_t _ptr_comment;
7171         TALLOC_CTX *_mem_save_comment_0;
7172         uint32_t _ptr_location;
7173         TALLOC_CTX *_mem_save_location_0;
7174         uint32_t _ptr_sepfile;
7175         TALLOC_CTX *_mem_save_sepfile_0;
7176         uint32_t _ptr_printprocessor;
7177         TALLOC_CTX *_mem_save_printprocessor_0;
7178         uint32_t _ptr_datatype;
7179         TALLOC_CTX *_mem_save_datatype_0;
7180         uint32_t _ptr_parameters;
7181         TALLOC_CTX *_mem_save_parameters_0;
7182         if (ndr_flags & NDR_SCALARS) {
7183                 NDR_CHECK(ndr_pull_align(ndr, 5));
7184                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
7185                 if (_ptr_servername) {
7186                         NDR_PULL_ALLOC(ndr, r->servername);
7187                 } else {
7188                         r->servername = NULL;
7189                 }
7190                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7191                 if (_ptr_printername) {
7192                         NDR_PULL_ALLOC(ndr, r->printername);
7193                 } else {
7194                         r->printername = NULL;
7195                 }
7196                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
7197                 if (_ptr_sharename) {
7198                         NDR_PULL_ALLOC(ndr, r->sharename);
7199                 } else {
7200                         r->sharename = NULL;
7201                 }
7202                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
7203                 if (_ptr_portname) {
7204                         NDR_PULL_ALLOC(ndr, r->portname);
7205                 } else {
7206                         r->portname = NULL;
7207                 }
7208                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
7209                 if (_ptr_drivername) {
7210                         NDR_PULL_ALLOC(ndr, r->drivername);
7211                 } else {
7212                         r->drivername = NULL;
7213                 }
7214                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
7215                 if (_ptr_comment) {
7216                         NDR_PULL_ALLOC(ndr, r->comment);
7217                 } else {
7218                         r->comment = NULL;
7219                 }
7220                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
7221                 if (_ptr_location) {
7222                         NDR_PULL_ALLOC(ndr, r->location);
7223                 } else {
7224                         r->location = NULL;
7225                 }
7226                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
7227                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
7228                 if (_ptr_sepfile) {
7229                         NDR_PULL_ALLOC(ndr, r->sepfile);
7230                 } else {
7231                         r->sepfile = NULL;
7232                 }
7233                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
7234                 if (_ptr_printprocessor) {
7235                         NDR_PULL_ALLOC(ndr, r->printprocessor);
7236                 } else {
7237                         r->printprocessor = NULL;
7238                 }
7239                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
7240                 if (_ptr_datatype) {
7241                         NDR_PULL_ALLOC(ndr, r->datatype);
7242                 } else {
7243                         r->datatype = NULL;
7244                 }
7245                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
7246                 if (_ptr_parameters) {
7247                         NDR_PULL_ALLOC(ndr, r->parameters);
7248                 } else {
7249                         r->parameters = NULL;
7250                 }
7251                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->secdesc_ptr));
7252                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7253                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
7254                 if (r->priority > 99) {
7255                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7256                 }
7257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
7258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
7259                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
7260                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7261                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
7262                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
7263                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7264         }
7265         if (ndr_flags & NDR_BUFFERS) {
7266                 if (r->servername) {
7267                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7268                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7269                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7270                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7271                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7272                                 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));
7273                         }
7274                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7275                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7276                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7277                 }
7278                 if (r->printername) {
7279                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7280                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7281                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7282                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7283                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7284                                 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));
7285                         }
7286                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7287                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7289                 }
7290                 if (r->sharename) {
7291                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
7292                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
7293                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
7294                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
7295                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
7296                                 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));
7297                         }
7298                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
7299                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
7300                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
7301                 }
7302                 if (r->portname) {
7303                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7304                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7305                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7306                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7307                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7308                                 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));
7309                         }
7310                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7311                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7312                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7313                 }
7314                 if (r->drivername) {
7315                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7316                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
7317                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
7318                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
7319                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
7320                                 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));
7321                         }
7322                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
7323                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
7324                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
7325                 }
7326                 if (r->comment) {
7327                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
7328                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
7329                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
7330                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
7331                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
7332                                 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));
7333                         }
7334                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
7335                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
7336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
7337                 }
7338                 if (r->location) {
7339                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
7340                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
7341                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
7342                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
7343                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
7344                                 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));
7345                         }
7346                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
7347                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
7348                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
7349                 }
7350                 if (r->sepfile) {
7351                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
7352                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
7353                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
7354                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
7355                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
7356                                 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));
7357                         }
7358                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
7359                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
7360                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
7361                 }
7362                 if (r->printprocessor) {
7363                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
7364                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
7365                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
7366                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
7367                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
7368                                 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));
7369                         }
7370                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
7371                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
7372                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
7373                 }
7374                 if (r->datatype) {
7375                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7376                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
7377                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
7378                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
7379                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
7380                                 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));
7381                         }
7382                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
7383                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
7384                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
7385                 }
7386                 if (r->parameters) {
7387                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
7388                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
7389                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
7390                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
7391                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
7392                                 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));
7393                         }
7394                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
7395                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
7396                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
7397                 }
7398         }
7399         return NDR_ERR_SUCCESS;
7400 }
7401
7402 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
7403 {
7404         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
7405         ndr->depth++;
7406         ndr_print_ptr(ndr, "servername", r->servername);
7407         ndr->depth++;
7408         if (r->servername) {
7409                 ndr_print_string(ndr, "servername", r->servername);
7410         }
7411         ndr->depth--;
7412         ndr_print_ptr(ndr, "printername", r->printername);
7413         ndr->depth++;
7414         if (r->printername) {
7415                 ndr_print_string(ndr, "printername", r->printername);
7416         }
7417         ndr->depth--;
7418         ndr_print_ptr(ndr, "sharename", r->sharename);
7419         ndr->depth++;
7420         if (r->sharename) {
7421                 ndr_print_string(ndr, "sharename", r->sharename);
7422         }
7423         ndr->depth--;
7424         ndr_print_ptr(ndr, "portname", r->portname);
7425         ndr->depth++;
7426         if (r->portname) {
7427                 ndr_print_string(ndr, "portname", r->portname);
7428         }
7429         ndr->depth--;
7430         ndr_print_ptr(ndr, "drivername", r->drivername);
7431         ndr->depth++;
7432         if (r->drivername) {
7433                 ndr_print_string(ndr, "drivername", r->drivername);
7434         }
7435         ndr->depth--;
7436         ndr_print_ptr(ndr, "comment", r->comment);
7437         ndr->depth++;
7438         if (r->comment) {
7439                 ndr_print_string(ndr, "comment", r->comment);
7440         }
7441         ndr->depth--;
7442         ndr_print_ptr(ndr, "location", r->location);
7443         ndr->depth++;
7444         if (r->location) {
7445                 ndr_print_string(ndr, "location", r->location);
7446         }
7447         ndr->depth--;
7448         ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7449         ndr_print_ptr(ndr, "sepfile", r->sepfile);
7450         ndr->depth++;
7451         if (r->sepfile) {
7452                 ndr_print_string(ndr, "sepfile", r->sepfile);
7453         }
7454         ndr->depth--;
7455         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
7456         ndr->depth++;
7457         if (r->printprocessor) {
7458                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
7459         }
7460         ndr->depth--;
7461         ndr_print_ptr(ndr, "datatype", r->datatype);
7462         ndr->depth++;
7463         if (r->datatype) {
7464                 ndr_print_string(ndr, "datatype", r->datatype);
7465         }
7466         ndr->depth--;
7467         ndr_print_ptr(ndr, "parameters", r->parameters);
7468         ndr->depth++;
7469         if (r->parameters) {
7470                 ndr_print_string(ndr, "parameters", r->parameters);
7471         }
7472         ndr->depth--;
7473         ndr_print_uint32(ndr, "secdesc_ptr", r->secdesc_ptr);
7474         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7475         ndr_print_uint32(ndr, "priority", r->priority);
7476         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
7477         ndr_print_uint32(ndr, "starttime", r->starttime);
7478         ndr_print_uint32(ndr, "untiltime", r->untiltime);
7479         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7480         ndr_print_uint32(ndr, "cjobs", r->cjobs);
7481         ndr_print_uint32(ndr, "averageppm", r->averageppm);
7482         ndr->depth--;
7483 }
7484
7485 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
7486 {
7487         if (ndr_flags & NDR_SCALARS) {
7488                 NDR_CHECK(ndr_push_align(ndr, 4));
7489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
7490                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7491         }
7492         if (ndr_flags & NDR_BUFFERS) {
7493         }
7494         return NDR_ERR_SUCCESS;
7495 }
7496
7497 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
7498 {
7499         if (ndr_flags & NDR_SCALARS) {
7500                 NDR_CHECK(ndr_pull_align(ndr, 4));
7501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
7502                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7503         }
7504         if (ndr_flags & NDR_BUFFERS) {
7505         }
7506         return NDR_ERR_SUCCESS;
7507 }
7508
7509 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
7510 {
7511         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
7512         ndr->depth++;
7513         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
7514         ndr->depth--;
7515 }
7516
7517 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
7518 {
7519         if (ndr_flags & NDR_SCALARS) {
7520                 NDR_CHECK(ndr_push_align(ndr, 5));
7521                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7522                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
7523                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7524                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7525         }
7526         if (ndr_flags & NDR_BUFFERS) {
7527                 if (r->printername) {
7528                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7529                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7530                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7531                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7532                 }
7533                 if (r->servername) {
7534                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7535                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7536                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7537                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7538                 }
7539         }
7540         return NDR_ERR_SUCCESS;
7541 }
7542
7543 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
7544 {
7545         uint32_t _ptr_printername;
7546         TALLOC_CTX *_mem_save_printername_0;
7547         uint32_t _ptr_servername;
7548         TALLOC_CTX *_mem_save_servername_0;
7549         if (ndr_flags & NDR_SCALARS) {
7550                 NDR_CHECK(ndr_pull_align(ndr, 5));
7551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7552                 if (_ptr_printername) {
7553                         NDR_PULL_ALLOC(ndr, r->printername);
7554                 } else {
7555                         r->printername = NULL;
7556                 }
7557                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
7558                 if (_ptr_servername) {
7559                         NDR_PULL_ALLOC(ndr, r->servername);
7560                 } else {
7561                         r->servername = NULL;
7562                 }
7563                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7564                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7565         }
7566         if (ndr_flags & NDR_BUFFERS) {
7567                 if (r->printername) {
7568                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7569                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7570                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7571                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7572                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7573                                 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));
7574                         }
7575                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7576                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7577                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7578                 }
7579                 if (r->servername) {
7580                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7581                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7582                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7583                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7584                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7585                                 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));
7586                         }
7587                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7588                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7589                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7590                 }
7591         }
7592         return NDR_ERR_SUCCESS;
7593 }
7594
7595 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
7596 {
7597         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
7598         ndr->depth++;
7599         ndr_print_ptr(ndr, "printername", r->printername);
7600         ndr->depth++;
7601         if (r->printername) {
7602                 ndr_print_string(ndr, "printername", r->printername);
7603         }
7604         ndr->depth--;
7605         ndr_print_ptr(ndr, "servername", r->servername);
7606         ndr->depth++;
7607         if (r->servername) {
7608                 ndr_print_string(ndr, "servername", r->servername);
7609         }
7610         ndr->depth--;
7611         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7612         ndr->depth--;
7613 }
7614
7615 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
7616 {
7617         if (ndr_flags & NDR_SCALARS) {
7618                 NDR_CHECK(ndr_push_align(ndr, 5));
7619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7620                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
7621                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7622                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
7623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
7624                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7625         }
7626         if (ndr_flags & NDR_BUFFERS) {
7627                 if (r->printername) {
7628                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7629                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7630                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7631                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7632                 }
7633                 if (r->portname) {
7634                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7635                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7636                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7637                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7638                 }
7639         }
7640         return NDR_ERR_SUCCESS;
7641 }
7642
7643 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
7644 {
7645         uint32_t _ptr_printername;
7646         TALLOC_CTX *_mem_save_printername_0;
7647         uint32_t _ptr_portname;
7648         TALLOC_CTX *_mem_save_portname_0;
7649         if (ndr_flags & NDR_SCALARS) {
7650                 NDR_CHECK(ndr_pull_align(ndr, 5));
7651                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7652                 if (_ptr_printername) {
7653                         NDR_PULL_ALLOC(ndr, r->printername);
7654                 } else {
7655                         r->printername = NULL;
7656                 }
7657                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
7658                 if (_ptr_portname) {
7659                         NDR_PULL_ALLOC(ndr, r->portname);
7660                 } else {
7661                         r->portname = NULL;
7662                 }
7663                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7664                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
7665                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
7666                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7667         }
7668         if (ndr_flags & NDR_BUFFERS) {
7669                 if (r->printername) {
7670                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7671                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7672                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7673                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7674                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7675                                 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));
7676                         }
7677                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7678                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7679                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7680                 }
7681                 if (r->portname) {
7682                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7683                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7684                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7685                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7686                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7687                                 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));
7688                         }
7689                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7690                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7691                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7692                 }
7693         }
7694         return NDR_ERR_SUCCESS;
7695 }
7696
7697 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
7698 {
7699         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
7700         ndr->depth++;
7701         ndr_print_ptr(ndr, "printername", r->printername);
7702         ndr->depth++;
7703         if (r->printername) {
7704                 ndr_print_string(ndr, "printername", r->printername);
7705         }
7706         ndr->depth--;
7707         ndr_print_ptr(ndr, "portname", r->portname);
7708         ndr->depth++;
7709         if (r->portname) {
7710                 ndr_print_string(ndr, "portname", r->portname);
7711         }
7712         ndr->depth--;
7713         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7714         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
7715         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
7716         ndr->depth--;
7717 }
7718
7719 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
7720 {
7721         if (ndr_flags & NDR_SCALARS) {
7722                 NDR_CHECK(ndr_push_align(ndr, 4));
7723                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
7724                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7725         }
7726         if (ndr_flags & NDR_BUFFERS) {
7727         }
7728         return NDR_ERR_SUCCESS;
7729 }
7730
7731 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
7732 {
7733         if (ndr_flags & NDR_SCALARS) {
7734                 NDR_CHECK(ndr_pull_align(ndr, 4));
7735                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7736                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7737         }
7738         if (ndr_flags & NDR_BUFFERS) {
7739         }
7740         return NDR_ERR_SUCCESS;
7741 }
7742
7743 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
7744 {
7745         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
7746         ndr->depth++;
7747         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7748         ndr->depth--;
7749 }
7750
7751 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
7752 {
7753         if (ndr_flags & NDR_SCALARS) {
7754                 NDR_CHECK(ndr_push_align(ndr, 5));
7755                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
7756                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
7757                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7758         }
7759         if (ndr_flags & NDR_BUFFERS) {
7760                 if (r->guid) {
7761                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7762                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7763                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7764                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7765                 }
7766         }
7767         return NDR_ERR_SUCCESS;
7768 }
7769
7770 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
7771 {
7772         uint32_t _ptr_guid;
7773         TALLOC_CTX *_mem_save_guid_0;
7774         if (ndr_flags & NDR_SCALARS) {
7775                 NDR_CHECK(ndr_pull_align(ndr, 5));
7776                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
7777                 if (_ptr_guid) {
7778                         NDR_PULL_ALLOC(ndr, r->guid);
7779                 } else {
7780                         r->guid = NULL;
7781                 }
7782                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
7783                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7784         }
7785         if (ndr_flags & NDR_BUFFERS) {
7786                 if (r->guid) {
7787                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7788                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
7789                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
7790                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
7791                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
7792                                 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));
7793                         }
7794                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
7795                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
7796                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
7797                 }
7798         }
7799         return NDR_ERR_SUCCESS;
7800 }
7801
7802 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
7803 {
7804         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
7805         ndr->depth++;
7806         ndr_print_ptr(ndr, "guid", r->guid);
7807         ndr->depth++;
7808         if (r->guid) {
7809                 ndr_print_string(ndr, "guid", r->guid);
7810         }
7811         ndr->depth--;
7812         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
7813         ndr->depth--;
7814 }
7815
7816 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo8 *r)
7817 {
7818         if (ndr_flags & NDR_SCALARS) {
7819                 NDR_CHECK(ndr_push_align(ndr, 4));
7820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
7821                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7822         }
7823         if (ndr_flags & NDR_BUFFERS) {
7824         }
7825         return NDR_ERR_SUCCESS;
7826 }
7827
7828 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo8 *r)
7829 {
7830         if (ndr_flags & NDR_SCALARS) {
7831                 NDR_CHECK(ndr_pull_align(ndr, 4));
7832                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
7833                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7834         }
7835         if (ndr_flags & NDR_BUFFERS) {
7836         }
7837         return NDR_ERR_SUCCESS;
7838 }
7839
7840 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo8 *r)
7841 {
7842         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo8");
7843         ndr->depth++;
7844         ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7845         ndr->depth--;
7846 }
7847
7848 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo9(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo9 *r)
7849 {
7850         if (ndr_flags & NDR_SCALARS) {
7851                 NDR_CHECK(ndr_push_align(ndr, 4));
7852                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
7853                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7854         }
7855         if (ndr_flags & NDR_BUFFERS) {
7856         }
7857         return NDR_ERR_SUCCESS;
7858 }
7859
7860 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo9(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo9 *r)
7861 {
7862         if (ndr_flags & NDR_SCALARS) {
7863                 NDR_CHECK(ndr_pull_align(ndr, 4));
7864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
7865                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7866         }
7867         if (ndr_flags & NDR_BUFFERS) {
7868         }
7869         return NDR_ERR_SUCCESS;
7870 }
7871
7872 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo9(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo9 *r)
7873 {
7874         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo9");
7875         ndr->depth++;
7876         ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7877         ndr->depth--;
7878 }
7879
7880 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
7881 {
7882         if (ndr_flags & NDR_SCALARS) {
7883                 int level = ndr_push_get_switch_value(ndr, r);
7884                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
7885                 NDR_CHECK(ndr_push_union_align(ndr, 5));
7886                 switch (level) {
7887                         case 0: {
7888                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
7889                         break; }
7890
7891                         case 1: {
7892                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
7893                         break; }
7894
7895                         case 2: {
7896                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
7897                         break; }
7898
7899                         case 3: {
7900                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
7901                         break; }
7902
7903                         case 4: {
7904                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
7905                         break; }
7906
7907                         case 5: {
7908                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
7909                         break; }
7910
7911                         case 6: {
7912                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
7913                         break; }
7914
7915                         case 7: {
7916                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
7917                         break; }
7918
7919                         case 8: {
7920                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
7921                         break; }
7922
7923                         case 9: {
7924                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
7925                         break; }
7926
7927                         default: {
7928                         break; }
7929
7930                 }
7931         }
7932         if (ndr_flags & NDR_BUFFERS) {
7933                 int level = ndr_push_get_switch_value(ndr, r);
7934                 switch (level) {
7935                         case 0:
7936                                 if (r->info0) {
7937                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7938                                 }
7939                         break;
7940
7941                         case 1:
7942                                 if (r->info1) {
7943                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7944                                 }
7945                         break;
7946
7947                         case 2:
7948                                 if (r->info2) {
7949                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7950                                 }
7951                         break;
7952
7953                         case 3:
7954                                 if (r->info3) {
7955                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7956                                 }
7957                         break;
7958
7959                         case 4:
7960                                 if (r->info4) {
7961                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7962                                 }
7963                         break;
7964
7965                         case 5:
7966                                 if (r->info5) {
7967                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7968                                 }
7969                         break;
7970
7971                         case 6:
7972                                 if (r->info6) {
7973                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7974                                 }
7975                         break;
7976
7977                         case 7:
7978                                 if (r->info7) {
7979                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7980                                 }
7981                         break;
7982
7983                         case 8:
7984                                 if (r->info8) {
7985                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo8(ndr, NDR_SCALARS, r->info8));
7986                                 }
7987                         break;
7988
7989                         case 9:
7990                                 if (r->info9) {
7991                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo9(ndr, NDR_SCALARS, r->info9));
7992                                 }
7993                         break;
7994
7995                         default:
7996                         break;
7997
7998                 }
7999         }
8000         return NDR_ERR_SUCCESS;
8001 }
8002
8003 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
8004 {
8005         int level;
8006         uint32_t _level;
8007         TALLOC_CTX *_mem_save_info0_0;
8008         TALLOC_CTX *_mem_save_info1_0;
8009         TALLOC_CTX *_mem_save_info2_0;
8010         TALLOC_CTX *_mem_save_info3_0;
8011         TALLOC_CTX *_mem_save_info4_0;
8012         TALLOC_CTX *_mem_save_info5_0;
8013         TALLOC_CTX *_mem_save_info6_0;
8014         TALLOC_CTX *_mem_save_info7_0;
8015         TALLOC_CTX *_mem_save_info8_0;
8016         TALLOC_CTX *_mem_save_info9_0;
8017         level = ndr_pull_get_switch_value(ndr, r);
8018         if (ndr_flags & NDR_SCALARS) {
8019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8020                 if (_level != level) {
8021                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8022                 }
8023                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8024                 switch (level) {
8025                         case 0: {
8026                                 uint32_t _ptr_info0;
8027                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
8028                                 if (_ptr_info0) {
8029                                         NDR_PULL_ALLOC(ndr, r->info0);
8030                                 } else {
8031                                         r->info0 = NULL;
8032                                 }
8033                         break; }
8034
8035                         case 1: {
8036                                 uint32_t _ptr_info1;
8037                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
8038                                 if (_ptr_info1) {
8039                                         NDR_PULL_ALLOC(ndr, r->info1);
8040                                 } else {
8041                                         r->info1 = NULL;
8042                                 }
8043                         break; }
8044
8045                         case 2: {
8046                                 uint32_t _ptr_info2;
8047                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
8048                                 if (_ptr_info2) {
8049                                         NDR_PULL_ALLOC(ndr, r->info2);
8050                                 } else {
8051                                         r->info2 = NULL;
8052                                 }
8053                         break; }
8054
8055                         case 3: {
8056                                 uint32_t _ptr_info3;
8057                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
8058                                 if (_ptr_info3) {
8059                                         NDR_PULL_ALLOC(ndr, r->info3);
8060                                 } else {
8061                                         r->info3 = NULL;
8062                                 }
8063                         break; }
8064
8065                         case 4: {
8066                                 uint32_t _ptr_info4;
8067                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
8068                                 if (_ptr_info4) {
8069                                         NDR_PULL_ALLOC(ndr, r->info4);
8070                                 } else {
8071                                         r->info4 = NULL;
8072                                 }
8073                         break; }
8074
8075                         case 5: {
8076                                 uint32_t _ptr_info5;
8077                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
8078                                 if (_ptr_info5) {
8079                                         NDR_PULL_ALLOC(ndr, r->info5);
8080                                 } else {
8081                                         r->info5 = NULL;
8082                                 }
8083                         break; }
8084
8085                         case 6: {
8086                                 uint32_t _ptr_info6;
8087                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
8088                                 if (_ptr_info6) {
8089                                         NDR_PULL_ALLOC(ndr, r->info6);
8090                                 } else {
8091                                         r->info6 = NULL;
8092                                 }
8093                         break; }
8094
8095                         case 7: {
8096                                 uint32_t _ptr_info7;
8097                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
8098                                 if (_ptr_info7) {
8099                                         NDR_PULL_ALLOC(ndr, r->info7);
8100                                 } else {
8101                                         r->info7 = NULL;
8102                                 }
8103                         break; }
8104
8105                         case 8: {
8106                                 uint32_t _ptr_info8;
8107                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
8108                                 if (_ptr_info8) {
8109                                         NDR_PULL_ALLOC(ndr, r->info8);
8110                                 } else {
8111                                         r->info8 = NULL;
8112                                 }
8113                         break; }
8114
8115                         case 9: {
8116                                 uint32_t _ptr_info9;
8117                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
8118                                 if (_ptr_info9) {
8119                                         NDR_PULL_ALLOC(ndr, r->info9);
8120                                 } else {
8121                                         r->info9 = NULL;
8122                                 }
8123                         break; }
8124
8125                         default: {
8126                         break; }
8127
8128                 }
8129         }
8130         if (ndr_flags & NDR_BUFFERS) {
8131                 switch (level) {
8132                         case 0:
8133                                 if (r->info0) {
8134                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
8135                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
8136                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
8137                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
8138                                 }
8139                         break;
8140
8141                         case 1:
8142                                 if (r->info1) {
8143                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
8144                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
8145                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
8146                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
8147                                 }
8148                         break;
8149
8150                         case 2:
8151                                 if (r->info2) {
8152                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
8153                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
8154                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
8155                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
8156                                 }
8157                         break;
8158
8159                         case 3:
8160                                 if (r->info3) {
8161                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
8162                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
8163                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
8164                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
8165                                 }
8166                         break;
8167
8168                         case 4:
8169                                 if (r->info4) {
8170                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
8171                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
8172                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
8173                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
8174                                 }
8175                         break;
8176
8177                         case 5:
8178                                 if (r->info5) {
8179                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
8180                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
8181                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
8182                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
8183                                 }
8184                         break;
8185
8186                         case 6:
8187                                 if (r->info6) {
8188                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
8189                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
8190                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
8191                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
8192                                 }
8193                         break;
8194
8195                         case 7:
8196                                 if (r->info7) {
8197                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
8198                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
8199                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
8200                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
8201                                 }
8202                         break;
8203
8204                         case 8:
8205                                 if (r->info8) {
8206                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
8207                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
8208                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo8(ndr, NDR_SCALARS, r->info8));
8209                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
8210                                 }
8211                         break;
8212
8213                         case 9:
8214                                 if (r->info9) {
8215                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
8216                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
8217                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo9(ndr, NDR_SCALARS, r->info9));
8218                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
8219                                 }
8220                         break;
8221
8222                         default:
8223                         break;
8224
8225                 }
8226         }
8227         return NDR_ERR_SUCCESS;
8228 }
8229
8230 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
8231 {
8232         int level;
8233         level = ndr_print_get_switch_value(ndr, r);
8234         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
8235         switch (level) {
8236                 case 0:
8237                         ndr_print_ptr(ndr, "info0", r->info0);
8238                         ndr->depth++;
8239                         if (r->info0) {
8240                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
8241                         }
8242                         ndr->depth--;
8243                 break;
8244
8245                 case 1:
8246                         ndr_print_ptr(ndr, "info1", r->info1);
8247                         ndr->depth++;
8248                         if (r->info1) {
8249                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
8250                         }
8251                         ndr->depth--;
8252                 break;
8253
8254                 case 2:
8255                         ndr_print_ptr(ndr, "info2", r->info2);
8256                         ndr->depth++;
8257                         if (r->info2) {
8258                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
8259                         }
8260                         ndr->depth--;
8261                 break;
8262
8263                 case 3:
8264                         ndr_print_ptr(ndr, "info3", r->info3);
8265                         ndr->depth++;
8266                         if (r->info3) {
8267                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
8268                         }
8269                         ndr->depth--;
8270                 break;
8271
8272                 case 4:
8273                         ndr_print_ptr(ndr, "info4", r->info4);
8274                         ndr->depth++;
8275                         if (r->info4) {
8276                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
8277                         }
8278                         ndr->depth--;
8279                 break;
8280
8281                 case 5:
8282                         ndr_print_ptr(ndr, "info5", r->info5);
8283                         ndr->depth++;
8284                         if (r->info5) {
8285                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
8286                         }
8287                         ndr->depth--;
8288                 break;
8289
8290                 case 6:
8291                         ndr_print_ptr(ndr, "info6", r->info6);
8292                         ndr->depth++;
8293                         if (r->info6) {
8294                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
8295                         }
8296                         ndr->depth--;
8297                 break;
8298
8299                 case 7:
8300                         ndr_print_ptr(ndr, "info7", r->info7);
8301                         ndr->depth++;
8302                         if (r->info7) {
8303                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
8304                         }
8305                         ndr->depth--;
8306                 break;
8307
8308                 case 8:
8309                         ndr_print_ptr(ndr, "info8", r->info8);
8310                         ndr->depth++;
8311                         if (r->info8) {
8312                                 ndr_print_spoolss_SetPrinterInfo8(ndr, "info8", r->info8);
8313                         }
8314                         ndr->depth--;
8315                 break;
8316
8317                 case 9:
8318                         ndr_print_ptr(ndr, "info9", r->info9);
8319                         ndr->depth++;
8320                         if (r->info9) {
8321                                 ndr_print_spoolss_SetPrinterInfo9(ndr, "info9", r->info9);
8322                         }
8323                         ndr->depth--;
8324                 break;
8325
8326                 default:
8327                 break;
8328
8329         }
8330 }
8331
8332 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
8333 {
8334         if (ndr_flags & NDR_SCALARS) {
8335                 NDR_CHECK(ndr_push_align(ndr, 5));
8336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8337                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
8338                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8339                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8340         }
8341         if (ndr_flags & NDR_BUFFERS) {
8342                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8343         }
8344         return NDR_ERR_SUCCESS;
8345 }
8346
8347 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
8348 {
8349         if (ndr_flags & NDR_SCALARS) {
8350                 NDR_CHECK(ndr_pull_align(ndr, 5));
8351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8352                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
8353                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8354                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8355         }
8356         if (ndr_flags & NDR_BUFFERS) {
8357                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8358         }
8359         return NDR_ERR_SUCCESS;
8360 }
8361
8362 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
8363 {
8364         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
8365         ndr->depth++;
8366         ndr_print_uint32(ndr, "level", r->level);
8367         ndr_print_set_switch_value(ndr, &r->info, r->level);
8368         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
8369         ndr->depth--;
8370 }
8371
8372 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
8373 {
8374         if (ndr_flags & NDR_SCALARS) {
8375                 NDR_CHECK(ndr_push_align(ndr, 4));
8376                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
8377                 {
8378                         uint32_t _flags_save_string_array = ndr->flags;
8379                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8380                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
8381                         ndr->flags = _flags_save_string_array;
8382                 }
8383                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8384         }
8385         if (ndr_flags & NDR_BUFFERS) {
8386         }
8387         return NDR_ERR_SUCCESS;
8388 }
8389
8390 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
8391 {
8392         if (ndr_flags & NDR_SCALARS) {
8393                 NDR_CHECK(ndr_pull_align(ndr, 4));
8394                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
8395                 {
8396                         uint32_t _flags_save_string_array = ndr->flags;
8397                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8398                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
8399                         ndr->flags = _flags_save_string_array;
8400                 }
8401                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8402         }
8403         if (ndr_flags & NDR_BUFFERS) {
8404         }
8405         return NDR_ERR_SUCCESS;
8406 }
8407
8408 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
8409 {
8410         ndr_print_struct(ndr, name, "spoolss_StringArray");
8411         ndr->depth++;
8412         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);
8413         ndr_print_string_array(ndr, "string", r->string);
8414         ndr->depth--;
8415 }
8416
8417 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
8418 {
8419         if (ndr_flags & NDR_SCALARS) {
8420                 NDR_CHECK(ndr_push_align(ndr, 5));
8421                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8422                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8423         }
8424         if (ndr_flags & NDR_BUFFERS) {
8425                 if (r->driver_name) {
8426                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8427                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8428                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8429                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8430                 }
8431         }
8432         return NDR_ERR_SUCCESS;
8433 }
8434
8435 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
8436 {
8437         uint32_t _ptr_driver_name;
8438         TALLOC_CTX *_mem_save_driver_name_0;
8439         if (ndr_flags & NDR_SCALARS) {
8440                 NDR_CHECK(ndr_pull_align(ndr, 5));
8441                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8442                 if (_ptr_driver_name) {
8443                         NDR_PULL_ALLOC(ndr, r->driver_name);
8444                 } else {
8445                         r->driver_name = NULL;
8446                 }
8447                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8448         }
8449         if (ndr_flags & NDR_BUFFERS) {
8450                 if (r->driver_name) {
8451                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8452                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8453                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8454                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8455                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8456                                 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));
8457                         }
8458                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8459                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8460                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8461                 }
8462         }
8463         return NDR_ERR_SUCCESS;
8464 }
8465
8466 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
8467 {
8468         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
8469         ndr->depth++;
8470         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8471         ndr->depth++;
8472         if (r->driver_name) {
8473                 ndr_print_string(ndr, "driver_name", r->driver_name);
8474         }
8475         ndr->depth--;
8476         ndr->depth--;
8477 }
8478
8479 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
8480 {
8481         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
8482         return NDR_ERR_SUCCESS;
8483 }
8484
8485 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
8486 {
8487         uint32_t v;
8488         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
8489         *r = v;
8490         return NDR_ERR_SUCCESS;
8491 }
8492
8493 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
8494 {
8495         const char *val = NULL;
8496
8497         switch (r) {
8498                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
8499                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
8500                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
8501                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
8502         }
8503         ndr_print_enum(ndr, name, "ENUM", val, r);
8504 }
8505
8506 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
8507 {
8508         if (ndr_flags & NDR_SCALARS) {
8509                 NDR_CHECK(ndr_push_align(ndr, 5));
8510                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8511                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8512                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8513                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8514                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8515                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8516                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8517         }
8518         if (ndr_flags & NDR_BUFFERS) {
8519                 if (r->driver_name) {
8520                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8521                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8522                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8523                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8524                 }
8525                 if (r->architecture) {
8526                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8527                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8528                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8529                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8530                 }
8531                 if (r->driver_path) {
8532                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8533                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8534                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8535                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8536                 }
8537                 if (r->data_file) {
8538                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8539                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8540                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8541                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8542                 }
8543                 if (r->config_file) {
8544                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8545                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8546                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8547                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8548                 }
8549         }
8550         return NDR_ERR_SUCCESS;
8551 }
8552
8553 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
8554 {
8555         uint32_t _ptr_driver_name;
8556         TALLOC_CTX *_mem_save_driver_name_0;
8557         uint32_t _ptr_architecture;
8558         TALLOC_CTX *_mem_save_architecture_0;
8559         uint32_t _ptr_driver_path;
8560         TALLOC_CTX *_mem_save_driver_path_0;
8561         uint32_t _ptr_data_file;
8562         TALLOC_CTX *_mem_save_data_file_0;
8563         uint32_t _ptr_config_file;
8564         TALLOC_CTX *_mem_save_config_file_0;
8565         if (ndr_flags & NDR_SCALARS) {
8566                 NDR_CHECK(ndr_pull_align(ndr, 5));
8567                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8568                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8569                 if (_ptr_driver_name) {
8570                         NDR_PULL_ALLOC(ndr, r->driver_name);
8571                 } else {
8572                         r->driver_name = NULL;
8573                 }
8574                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8575                 if (_ptr_architecture) {
8576                         NDR_PULL_ALLOC(ndr, r->architecture);
8577                 } else {
8578                         r->architecture = NULL;
8579                 }
8580                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8581                 if (_ptr_driver_path) {
8582                         NDR_PULL_ALLOC(ndr, r->driver_path);
8583                 } else {
8584                         r->driver_path = NULL;
8585                 }
8586                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8587                 if (_ptr_data_file) {
8588                         NDR_PULL_ALLOC(ndr, r->data_file);
8589                 } else {
8590                         r->data_file = NULL;
8591                 }
8592                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8593                 if (_ptr_config_file) {
8594                         NDR_PULL_ALLOC(ndr, r->config_file);
8595                 } else {
8596                         r->config_file = NULL;
8597                 }
8598                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8599         }
8600         if (ndr_flags & NDR_BUFFERS) {
8601                 if (r->driver_name) {
8602                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8603                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8604                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8605                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8606                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8607                                 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));
8608                         }
8609                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8610                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8611                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8612                 }
8613                 if (r->architecture) {
8614                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8615                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8616                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8617                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8618                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8619                                 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));
8620                         }
8621                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8622                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8623                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8624                 }
8625                 if (r->driver_path) {
8626                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8627                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8628                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8629                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8630                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8631                                 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));
8632                         }
8633                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8634                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8635                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8636                 }
8637                 if (r->data_file) {
8638                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8639                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8640                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8641                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8642                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8643                                 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));
8644                         }
8645                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8646                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8647                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8648                 }
8649                 if (r->config_file) {
8650                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8651                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8652                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8653                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8654                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8655                                 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));
8656                         }
8657                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8658                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8659                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8660                 }
8661         }
8662         return NDR_ERR_SUCCESS;
8663 }
8664
8665 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
8666 {
8667         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
8668         ndr->depth++;
8669         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8670         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8671         ndr->depth++;
8672         if (r->driver_name) {
8673                 ndr_print_string(ndr, "driver_name", r->driver_name);
8674         }
8675         ndr->depth--;
8676         ndr_print_ptr(ndr, "architecture", r->architecture);
8677         ndr->depth++;
8678         if (r->architecture) {
8679                 ndr_print_string(ndr, "architecture", r->architecture);
8680         }
8681         ndr->depth--;
8682         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8683         ndr->depth++;
8684         if (r->driver_path) {
8685                 ndr_print_string(ndr, "driver_path", r->driver_path);
8686         }
8687         ndr->depth--;
8688         ndr_print_ptr(ndr, "data_file", r->data_file);
8689         ndr->depth++;
8690         if (r->data_file) {
8691                 ndr_print_string(ndr, "data_file", r->data_file);
8692         }
8693         ndr->depth--;
8694         ndr_print_ptr(ndr, "config_file", r->config_file);
8695         ndr->depth++;
8696         if (r->config_file) {
8697                 ndr_print_string(ndr, "config_file", r->config_file);
8698         }
8699         ndr->depth--;
8700         ndr->depth--;
8701 }
8702
8703 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
8704 {
8705         if (ndr_flags & NDR_SCALARS) {
8706                 NDR_CHECK(ndr_push_align(ndr, 5));
8707                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8708                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8709                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8710                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8711                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8712                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8713                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8714                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8715                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8717                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8718                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8719         }
8720         if (ndr_flags & NDR_BUFFERS) {
8721                 if (r->driver_name) {
8722                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8723                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8724                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8725                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8726                 }
8727                 if (r->architecture) {
8728                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8729                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8730                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8731                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8732                 }
8733                 if (r->driver_path) {
8734                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8735                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8736                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8737                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8738                 }
8739                 if (r->data_file) {
8740                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8741                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8742                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8743                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8744                 }
8745                 if (r->config_file) {
8746                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8747                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8748                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8749                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8750                 }
8751                 if (r->help_file) {
8752                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8753                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8754                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8755                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8756                 }
8757                 if (r->monitor_name) {
8758                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8759                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8760                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8761                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8762                 }
8763                 if (r->default_datatype) {
8764                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8765                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8766                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8767                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8768                 }
8769                 if (r->dependent_files) {
8770                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8771                 }
8772         }
8773         return NDR_ERR_SUCCESS;
8774 }
8775
8776 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
8777 {
8778         uint32_t _ptr_driver_name;
8779         TALLOC_CTX *_mem_save_driver_name_0;
8780         uint32_t _ptr_architecture;
8781         TALLOC_CTX *_mem_save_architecture_0;
8782         uint32_t _ptr_driver_path;
8783         TALLOC_CTX *_mem_save_driver_path_0;
8784         uint32_t _ptr_data_file;
8785         TALLOC_CTX *_mem_save_data_file_0;
8786         uint32_t _ptr_config_file;
8787         TALLOC_CTX *_mem_save_config_file_0;
8788         uint32_t _ptr_help_file;
8789         TALLOC_CTX *_mem_save_help_file_0;
8790         uint32_t _ptr_monitor_name;
8791         TALLOC_CTX *_mem_save_monitor_name_0;
8792         uint32_t _ptr_default_datatype;
8793         TALLOC_CTX *_mem_save_default_datatype_0;
8794         uint32_t _ptr_dependent_files;
8795         TALLOC_CTX *_mem_save_dependent_files_0;
8796         if (ndr_flags & NDR_SCALARS) {
8797                 NDR_CHECK(ndr_pull_align(ndr, 5));
8798                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8799                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8800                 if (_ptr_driver_name) {
8801                         NDR_PULL_ALLOC(ndr, r->driver_name);
8802                 } else {
8803                         r->driver_name = NULL;
8804                 }
8805                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8806                 if (_ptr_architecture) {
8807                         NDR_PULL_ALLOC(ndr, r->architecture);
8808                 } else {
8809                         r->architecture = NULL;
8810                 }
8811                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8812                 if (_ptr_driver_path) {
8813                         NDR_PULL_ALLOC(ndr, r->driver_path);
8814                 } else {
8815                         r->driver_path = NULL;
8816                 }
8817                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8818                 if (_ptr_data_file) {
8819                         NDR_PULL_ALLOC(ndr, r->data_file);
8820                 } else {
8821                         r->data_file = NULL;
8822                 }
8823                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8824                 if (_ptr_config_file) {
8825                         NDR_PULL_ALLOC(ndr, r->config_file);
8826                 } else {
8827                         r->config_file = NULL;
8828                 }
8829                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8830                 if (_ptr_help_file) {
8831                         NDR_PULL_ALLOC(ndr, r->help_file);
8832                 } else {
8833                         r->help_file = NULL;
8834                 }
8835                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8836                 if (_ptr_monitor_name) {
8837                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8838                 } else {
8839                         r->monitor_name = NULL;
8840                 }
8841                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8842                 if (_ptr_default_datatype) {
8843                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8844                 } else {
8845                         r->default_datatype = NULL;
8846                 }
8847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8848                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8849                 if (_ptr_dependent_files) {
8850                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8851                 } else {
8852                         r->dependent_files = NULL;
8853                 }
8854                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8855         }
8856         if (ndr_flags & NDR_BUFFERS) {
8857                 if (r->driver_name) {
8858                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8859                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8860                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8861                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8862                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8863                                 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));
8864                         }
8865                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8866                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8867                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8868                 }
8869                 if (r->architecture) {
8870                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8871                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8872                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8873                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8874                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8875                                 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));
8876                         }
8877                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8878                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8879                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8880                 }
8881                 if (r->driver_path) {
8882                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8883                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8884                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8885                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8886                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8887                                 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));
8888                         }
8889                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8890                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8891                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8892                 }
8893                 if (r->data_file) {
8894                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8895                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8896                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8897                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8898                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8899                                 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));
8900                         }
8901                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8902                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8903                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8904                 }
8905                 if (r->config_file) {
8906                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8907                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8908                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8909                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8910                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8911                                 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));
8912                         }
8913                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8914                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8915                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8916                 }
8917                 if (r->help_file) {
8918                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8919                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8920                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8921                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8922                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8923                                 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));
8924                         }
8925                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8926                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8927                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8928                 }
8929                 if (r->monitor_name) {
8930                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8931                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8932                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8933                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8934                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8935                                 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));
8936                         }
8937                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8938                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8939                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8940                 }
8941                 if (r->default_datatype) {
8942                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8943                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8944                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8945                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8946                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8947                                 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));
8948                         }
8949                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8950                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8951                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8952                 }
8953                 if (r->dependent_files) {
8954                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8955                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8956                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8957                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8958                 }
8959         }
8960         return NDR_ERR_SUCCESS;
8961 }
8962
8963 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
8964 {
8965         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
8966         ndr->depth++;
8967         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8968         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8969         ndr->depth++;
8970         if (r->driver_name) {
8971                 ndr_print_string(ndr, "driver_name", r->driver_name);
8972         }
8973         ndr->depth--;
8974         ndr_print_ptr(ndr, "architecture", r->architecture);
8975         ndr->depth++;
8976         if (r->architecture) {
8977                 ndr_print_string(ndr, "architecture", r->architecture);
8978         }
8979         ndr->depth--;
8980         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8981         ndr->depth++;
8982         if (r->driver_path) {
8983                 ndr_print_string(ndr, "driver_path", r->driver_path);
8984         }
8985         ndr->depth--;
8986         ndr_print_ptr(ndr, "data_file", r->data_file);
8987         ndr->depth++;
8988         if (r->data_file) {
8989                 ndr_print_string(ndr, "data_file", r->data_file);
8990         }
8991         ndr->depth--;
8992         ndr_print_ptr(ndr, "config_file", r->config_file);
8993         ndr->depth++;
8994         if (r->config_file) {
8995                 ndr_print_string(ndr, "config_file", r->config_file);
8996         }
8997         ndr->depth--;
8998         ndr_print_ptr(ndr, "help_file", r->help_file);
8999         ndr->depth++;
9000         if (r->help_file) {
9001                 ndr_print_string(ndr, "help_file", r->help_file);
9002         }
9003         ndr->depth--;
9004         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9005         ndr->depth++;
9006         if (r->monitor_name) {
9007                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9008         }
9009         ndr->depth--;
9010         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9011         ndr->depth++;
9012         if (r->default_datatype) {
9013                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9014         }
9015         ndr->depth--;
9016         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);
9017         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9018         ndr->depth++;
9019         if (r->dependent_files) {
9020                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9021         }
9022         ndr->depth--;
9023         ndr->depth--;
9024 }
9025
9026 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
9027 {
9028         if (ndr_flags & NDR_SCALARS) {
9029                 NDR_CHECK(ndr_push_align(ndr, 5));
9030                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9031                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9033                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9037                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9038                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9040                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9041                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9042                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9043                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9044         }
9045         if (ndr_flags & NDR_BUFFERS) {
9046                 if (r->driver_name) {
9047                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9048                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9049                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9050                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9051                 }
9052                 if (r->architecture) {
9053                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9054                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9055                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9056                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9057                 }
9058                 if (r->driver_path) {
9059                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9060                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9061                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9062                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9063                 }
9064                 if (r->data_file) {
9065                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9066                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9067                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9068                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9069                 }
9070                 if (r->config_file) {
9071                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9072                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9073                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9074                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9075                 }
9076                 if (r->help_file) {
9077                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9078                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9079                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9080                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9081                 }
9082                 if (r->monitor_name) {
9083                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9084                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9085                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9086                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9087                 }
9088                 if (r->default_datatype) {
9089                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9090                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9091                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9092                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9093                 }
9094                 if (r->dependent_files) {
9095                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9096                 }
9097                 if (r->previous_names) {
9098                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9099                 }
9100         }
9101         return NDR_ERR_SUCCESS;
9102 }
9103
9104 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
9105 {
9106         uint32_t _ptr_driver_name;
9107         TALLOC_CTX *_mem_save_driver_name_0;
9108         uint32_t _ptr_architecture;
9109         TALLOC_CTX *_mem_save_architecture_0;
9110         uint32_t _ptr_driver_path;
9111         TALLOC_CTX *_mem_save_driver_path_0;
9112         uint32_t _ptr_data_file;
9113         TALLOC_CTX *_mem_save_data_file_0;
9114         uint32_t _ptr_config_file;
9115         TALLOC_CTX *_mem_save_config_file_0;
9116         uint32_t _ptr_help_file;
9117         TALLOC_CTX *_mem_save_help_file_0;
9118         uint32_t _ptr_monitor_name;
9119         TALLOC_CTX *_mem_save_monitor_name_0;
9120         uint32_t _ptr_default_datatype;
9121         TALLOC_CTX *_mem_save_default_datatype_0;
9122         uint32_t _ptr_dependent_files;
9123         TALLOC_CTX *_mem_save_dependent_files_0;
9124         uint32_t _ptr_previous_names;
9125         TALLOC_CTX *_mem_save_previous_names_0;
9126         if (ndr_flags & NDR_SCALARS) {
9127                 NDR_CHECK(ndr_pull_align(ndr, 5));
9128                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9130                 if (_ptr_driver_name) {
9131                         NDR_PULL_ALLOC(ndr, r->driver_name);
9132                 } else {
9133                         r->driver_name = NULL;
9134                 }
9135                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9136                 if (_ptr_architecture) {
9137                         NDR_PULL_ALLOC(ndr, r->architecture);
9138                 } else {
9139                         r->architecture = NULL;
9140                 }
9141                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9142                 if (_ptr_driver_path) {
9143                         NDR_PULL_ALLOC(ndr, r->driver_path);
9144                 } else {
9145                         r->driver_path = NULL;
9146                 }
9147                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9148                 if (_ptr_data_file) {
9149                         NDR_PULL_ALLOC(ndr, r->data_file);
9150                 } else {
9151                         r->data_file = NULL;
9152                 }
9153                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9154                 if (_ptr_config_file) {
9155                         NDR_PULL_ALLOC(ndr, r->config_file);
9156                 } else {
9157                         r->config_file = NULL;
9158                 }
9159                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9160                 if (_ptr_help_file) {
9161                         NDR_PULL_ALLOC(ndr, r->help_file);
9162                 } else {
9163                         r->help_file = NULL;
9164                 }
9165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9166                 if (_ptr_monitor_name) {
9167                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9168                 } else {
9169                         r->monitor_name = NULL;
9170                 }
9171                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9172                 if (_ptr_default_datatype) {
9173                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9174                 } else {
9175                         r->default_datatype = NULL;
9176                 }
9177                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9178                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9179                 if (_ptr_dependent_files) {
9180                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9181                 } else {
9182                         r->dependent_files = NULL;
9183                 }
9184                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9185                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9186                 if (_ptr_previous_names) {
9187                         NDR_PULL_ALLOC(ndr, r->previous_names);
9188                 } else {
9189                         r->previous_names = NULL;
9190                 }
9191                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9192         }
9193         if (ndr_flags & NDR_BUFFERS) {
9194                 if (r->driver_name) {
9195                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9196                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9197                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9198                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9199                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9200                                 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));
9201                         }
9202                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9203                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9204                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9205                 }
9206                 if (r->architecture) {
9207                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9208                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9209                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9210                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9211                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9212                                 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));
9213                         }
9214                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9215                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9216                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9217                 }
9218                 if (r->driver_path) {
9219                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9220                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9221                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9222                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9223                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9224                                 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));
9225                         }
9226                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9227                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9228                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9229                 }
9230                 if (r->data_file) {
9231                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9232                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9233                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9234                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9235                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9236                                 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));
9237                         }
9238                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9239                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9240                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9241                 }
9242                 if (r->config_file) {
9243                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9244                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9245                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9246                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9247                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9248                                 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));
9249                         }
9250                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9251                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9252                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9253                 }
9254                 if (r->help_file) {
9255                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9256                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9257                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9258                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9259                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9260                                 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));
9261                         }
9262                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9263                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9264                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9265                 }
9266                 if (r->monitor_name) {
9267                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9268                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9269                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9270                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9271                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9272                                 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));
9273                         }
9274                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9275                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9276                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9277                 }
9278                 if (r->default_datatype) {
9279                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9280                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9281                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9282                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9283                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9284                                 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));
9285                         }
9286                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9287                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9289                 }
9290                 if (r->dependent_files) {
9291                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9292                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9293                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9294                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9295                 }
9296                 if (r->previous_names) {
9297                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9298                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9299                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9300                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9301                 }
9302         }
9303         return NDR_ERR_SUCCESS;
9304 }
9305
9306 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
9307 {
9308         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
9309         ndr->depth++;
9310         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9311         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9312         ndr->depth++;
9313         if (r->driver_name) {
9314                 ndr_print_string(ndr, "driver_name", r->driver_name);
9315         }
9316         ndr->depth--;
9317         ndr_print_ptr(ndr, "architecture", r->architecture);
9318         ndr->depth++;
9319         if (r->architecture) {
9320                 ndr_print_string(ndr, "architecture", r->architecture);
9321         }
9322         ndr->depth--;
9323         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9324         ndr->depth++;
9325         if (r->driver_path) {
9326                 ndr_print_string(ndr, "driver_path", r->driver_path);
9327         }
9328         ndr->depth--;
9329         ndr_print_ptr(ndr, "data_file", r->data_file);
9330         ndr->depth++;
9331         if (r->data_file) {
9332                 ndr_print_string(ndr, "data_file", r->data_file);
9333         }
9334         ndr->depth--;
9335         ndr_print_ptr(ndr, "config_file", r->config_file);
9336         ndr->depth++;
9337         if (r->config_file) {
9338                 ndr_print_string(ndr, "config_file", r->config_file);
9339         }
9340         ndr->depth--;
9341         ndr_print_ptr(ndr, "help_file", r->help_file);
9342         ndr->depth++;
9343         if (r->help_file) {
9344                 ndr_print_string(ndr, "help_file", r->help_file);
9345         }
9346         ndr->depth--;
9347         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9348         ndr->depth++;
9349         if (r->monitor_name) {
9350                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9351         }
9352         ndr->depth--;
9353         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9354         ndr->depth++;
9355         if (r->default_datatype) {
9356                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9357         }
9358         ndr->depth--;
9359         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);
9360         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9361         ndr->depth++;
9362         if (r->dependent_files) {
9363                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9364         }
9365         ndr->depth--;
9366         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);
9367         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9368         ndr->depth++;
9369         if (r->previous_names) {
9370                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9371         }
9372         ndr->depth--;
9373         ndr->depth--;
9374 }
9375
9376 static enum ndr_err_code ndr_push_spoolss_DriverAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9377 {
9378         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9379         return NDR_ERR_SUCCESS;
9380 }
9381
9382 static enum ndr_err_code ndr_pull_spoolss_DriverAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9383 {
9384         uint32_t v;
9385         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9386         *r = v;
9387         return NDR_ERR_SUCCESS;
9388 }
9389
9390 _PUBLIC_ void ndr_print_spoolss_DriverAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
9391 {
9392         ndr_print_uint32(ndr, name, r);
9393         ndr->depth++;
9394         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_DRIVER_PACKAGE_AWARE", PRINTER_DRIVER_PACKAGE_AWARE, r);
9395         ndr->depth--;
9396 }
9397
9398 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
9399 {
9400         if (ndr_flags & NDR_SCALARS) {
9401                 NDR_CHECK(ndr_push_align(ndr, 8));
9402                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9403                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9404                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9405                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9406                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9407                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9408                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9409                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9410                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9412                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9414                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9415                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9416                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9417                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9418                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9419                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9420                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9421                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9422         }
9423         if (ndr_flags & NDR_BUFFERS) {
9424                 if (r->driver_name) {
9425                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9426                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9427                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9428                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9429                 }
9430                 if (r->architecture) {
9431                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9432                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9433                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9434                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9435                 }
9436                 if (r->driver_path) {
9437                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9438                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9439                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9440                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9441                 }
9442                 if (r->data_file) {
9443                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9444                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9445                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9446                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9447                 }
9448                 if (r->config_file) {
9449                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9450                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9451                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9452                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9453                 }
9454                 if (r->help_file) {
9455                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9456                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9457                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9458                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9459                 }
9460                 if (r->monitor_name) {
9461                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9462                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9463                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9464                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9465                 }
9466                 if (r->default_datatype) {
9467                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9468                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9469                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9470                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9471                 }
9472                 if (r->dependent_files) {
9473                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9474                 }
9475                 if (r->previous_names) {
9476                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9477                 }
9478                 if (r->manufacturer_name) {
9479                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9480                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9481                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9482                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9483                 }
9484                 if (r->manufacturer_url) {
9485                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9486                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9487                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9488                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9489                 }
9490                 if (r->hardware_id) {
9491                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9492                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9493                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9494                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9495                 }
9496                 if (r->provider) {
9497                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9498                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9499                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9500                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9501                 }
9502         }
9503         return NDR_ERR_SUCCESS;
9504 }
9505
9506 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
9507 {
9508         uint32_t _ptr_driver_name;
9509         TALLOC_CTX *_mem_save_driver_name_0;
9510         uint32_t _ptr_architecture;
9511         TALLOC_CTX *_mem_save_architecture_0;
9512         uint32_t _ptr_driver_path;
9513         TALLOC_CTX *_mem_save_driver_path_0;
9514         uint32_t _ptr_data_file;
9515         TALLOC_CTX *_mem_save_data_file_0;
9516         uint32_t _ptr_config_file;
9517         TALLOC_CTX *_mem_save_config_file_0;
9518         uint32_t _ptr_help_file;
9519         TALLOC_CTX *_mem_save_help_file_0;
9520         uint32_t _ptr_monitor_name;
9521         TALLOC_CTX *_mem_save_monitor_name_0;
9522         uint32_t _ptr_default_datatype;
9523         TALLOC_CTX *_mem_save_default_datatype_0;
9524         uint32_t _ptr_dependent_files;
9525         TALLOC_CTX *_mem_save_dependent_files_0;
9526         uint32_t _ptr_previous_names;
9527         TALLOC_CTX *_mem_save_previous_names_0;
9528         uint32_t _ptr_manufacturer_name;
9529         TALLOC_CTX *_mem_save_manufacturer_name_0;
9530         uint32_t _ptr_manufacturer_url;
9531         TALLOC_CTX *_mem_save_manufacturer_url_0;
9532         uint32_t _ptr_hardware_id;
9533         TALLOC_CTX *_mem_save_hardware_id_0;
9534         uint32_t _ptr_provider;
9535         TALLOC_CTX *_mem_save_provider_0;
9536         if (ndr_flags & NDR_SCALARS) {
9537                 NDR_CHECK(ndr_pull_align(ndr, 8));
9538                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9539                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9540                 if (_ptr_driver_name) {
9541                         NDR_PULL_ALLOC(ndr, r->driver_name);
9542                 } else {
9543                         r->driver_name = NULL;
9544                 }
9545                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9546                 if (_ptr_architecture) {
9547                         NDR_PULL_ALLOC(ndr, r->architecture);
9548                 } else {
9549                         r->architecture = NULL;
9550                 }
9551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9552                 if (_ptr_driver_path) {
9553                         NDR_PULL_ALLOC(ndr, r->driver_path);
9554                 } else {
9555                         r->driver_path = NULL;
9556                 }
9557                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9558                 if (_ptr_data_file) {
9559                         NDR_PULL_ALLOC(ndr, r->data_file);
9560                 } else {
9561                         r->data_file = NULL;
9562                 }
9563                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9564                 if (_ptr_config_file) {
9565                         NDR_PULL_ALLOC(ndr, r->config_file);
9566                 } else {
9567                         r->config_file = NULL;
9568                 }
9569                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9570                 if (_ptr_help_file) {
9571                         NDR_PULL_ALLOC(ndr, r->help_file);
9572                 } else {
9573                         r->help_file = NULL;
9574                 }
9575                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9576                 if (_ptr_monitor_name) {
9577                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9578                 } else {
9579                         r->monitor_name = NULL;
9580                 }
9581                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9582                 if (_ptr_default_datatype) {
9583                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9584                 } else {
9585                         r->default_datatype = NULL;
9586                 }
9587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9588                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9589                 if (_ptr_dependent_files) {
9590                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9591                 } else {
9592                         r->dependent_files = NULL;
9593                 }
9594                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9595                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9596                 if (_ptr_previous_names) {
9597                         NDR_PULL_ALLOC(ndr, r->previous_names);
9598                 } else {
9599                         r->previous_names = NULL;
9600                 }
9601                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9602                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9603                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9604                 if (_ptr_manufacturer_name) {
9605                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9606                 } else {
9607                         r->manufacturer_name = NULL;
9608                 }
9609                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9610                 if (_ptr_manufacturer_url) {
9611                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9612                 } else {
9613                         r->manufacturer_url = NULL;
9614                 }
9615                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9616                 if (_ptr_hardware_id) {
9617                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9618                 } else {
9619                         r->hardware_id = NULL;
9620                 }
9621                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9622                 if (_ptr_provider) {
9623                         NDR_PULL_ALLOC(ndr, r->provider);
9624                 } else {
9625                         r->provider = NULL;
9626                 }
9627                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9628         }
9629         if (ndr_flags & NDR_BUFFERS) {
9630                 if (r->driver_name) {
9631                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9632                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9633                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9634                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9635                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9636                                 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));
9637                         }
9638                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9639                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9640                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9641                 }
9642                 if (r->architecture) {
9643                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9644                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9645                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9646                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9647                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9648                                 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));
9649                         }
9650                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9651                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9652                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9653                 }
9654                 if (r->driver_path) {
9655                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9656                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9657                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9658                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9659                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9660                                 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));
9661                         }
9662                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9663                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9664                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9665                 }
9666                 if (r->data_file) {
9667                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9668                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9669                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9670                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9671                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9672                                 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));
9673                         }
9674                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9675                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9676                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9677                 }
9678                 if (r->config_file) {
9679                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9680                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9681                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9682                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9683                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9684                                 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));
9685                         }
9686                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9687                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9688                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9689                 }
9690                 if (r->help_file) {
9691                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9692                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9693                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9694                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9695                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9696                                 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));
9697                         }
9698                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9699                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9700                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9701                 }
9702                 if (r->monitor_name) {
9703                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9704                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9705                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9706                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9707                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9708                                 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));
9709                         }
9710                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9711                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9712                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9713                 }
9714                 if (r->default_datatype) {
9715                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9716                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9717                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9718                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9719                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9720                                 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));
9721                         }
9722                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9723                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9724                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9725                 }
9726                 if (r->dependent_files) {
9727                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9728                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9729                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9730                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9731                 }
9732                 if (r->previous_names) {
9733                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9734                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9735                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9736                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9737                 }
9738                 if (r->manufacturer_name) {
9739                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9740                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9741                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9742                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9743                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9744                                 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));
9745                         }
9746                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9747                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9749                 }
9750                 if (r->manufacturer_url) {
9751                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9752                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9753                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9754                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9755                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9756                                 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));
9757                         }
9758                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9759                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9760                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9761                 }
9762                 if (r->hardware_id) {
9763                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9764                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9765                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9766                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9767                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9768                                 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));
9769                         }
9770                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9771                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9772                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9773                 }
9774                 if (r->provider) {
9775                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9776                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9777                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9778                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9779                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9780                                 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));
9781                         }
9782                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9783                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9784                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9785                 }
9786         }
9787         return NDR_ERR_SUCCESS;
9788 }
9789
9790 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
9791 {
9792         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
9793         ndr->depth++;
9794         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9795         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9796         ndr->depth++;
9797         if (r->driver_name) {
9798                 ndr_print_string(ndr, "driver_name", r->driver_name);
9799         }
9800         ndr->depth--;
9801         ndr_print_ptr(ndr, "architecture", r->architecture);
9802         ndr->depth++;
9803         if (r->architecture) {
9804                 ndr_print_string(ndr, "architecture", r->architecture);
9805         }
9806         ndr->depth--;
9807         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9808         ndr->depth++;
9809         if (r->driver_path) {
9810                 ndr_print_string(ndr, "driver_path", r->driver_path);
9811         }
9812         ndr->depth--;
9813         ndr_print_ptr(ndr, "data_file", r->data_file);
9814         ndr->depth++;
9815         if (r->data_file) {
9816                 ndr_print_string(ndr, "data_file", r->data_file);
9817         }
9818         ndr->depth--;
9819         ndr_print_ptr(ndr, "config_file", r->config_file);
9820         ndr->depth++;
9821         if (r->config_file) {
9822                 ndr_print_string(ndr, "config_file", r->config_file);
9823         }
9824         ndr->depth--;
9825         ndr_print_ptr(ndr, "help_file", r->help_file);
9826         ndr->depth++;
9827         if (r->help_file) {
9828                 ndr_print_string(ndr, "help_file", r->help_file);
9829         }
9830         ndr->depth--;
9831         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9832         ndr->depth++;
9833         if (r->monitor_name) {
9834                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9835         }
9836         ndr->depth--;
9837         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9838         ndr->depth++;
9839         if (r->default_datatype) {
9840                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9841         }
9842         ndr->depth--;
9843         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);
9844         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9845         ndr->depth++;
9846         if (r->dependent_files) {
9847                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9848         }
9849         ndr->depth--;
9850         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);
9851         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9852         ndr->depth++;
9853         if (r->previous_names) {
9854                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9855         }
9856         ndr->depth--;
9857         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9858         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9859         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9860         ndr->depth++;
9861         if (r->manufacturer_name) {
9862                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9863         }
9864         ndr->depth--;
9865         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9866         ndr->depth++;
9867         if (r->manufacturer_url) {
9868                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9869         }
9870         ndr->depth--;
9871         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9872         ndr->depth++;
9873         if (r->hardware_id) {
9874                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9875         }
9876         ndr->depth--;
9877         ndr_print_ptr(ndr, "provider", r->provider);
9878         ndr->depth++;
9879         if (r->provider) {
9880                 ndr_print_string(ndr, "provider", r->provider);
9881         }
9882         ndr->depth--;
9883         ndr->depth--;
9884 }
9885
9886 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
9887 {
9888         if (ndr_flags & NDR_SCALARS) {
9889                 NDR_CHECK(ndr_push_align(ndr, 8));
9890                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9891                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9892                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9893                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9894                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9895                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9896                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9897                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9898                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9899                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9900                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9902                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9903                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9904                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9905                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9906                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9907                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9908                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9909                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
9910                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
9911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9912                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
9913                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
9914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9916                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
9917                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9918                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9919                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9920         }
9921         if (ndr_flags & NDR_BUFFERS) {
9922                 if (r->driver_name) {
9923                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9924                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9925                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9926                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9927                 }
9928                 if (r->architecture) {
9929                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9930                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9931                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9932                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9933                 }
9934                 if (r->driver_path) {
9935                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9936                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9937                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9938                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9939                 }
9940                 if (r->data_file) {
9941                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9942                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9943                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9944                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9945                 }
9946                 if (r->config_file) {
9947                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9948                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9949                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9950                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9951                 }
9952                 if (r->help_file) {
9953                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9954                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9955                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9956                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9957                 }
9958                 if (r->monitor_name) {
9959                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9960                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9961                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9962                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9963                 }
9964                 if (r->default_datatype) {
9965                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9966                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9967                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9968                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9969                 }
9970                 if (r->dependent_files) {
9971                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9972                 }
9973                 if (r->previous_names) {
9974                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9975                 }
9976                 if (r->manufacturer_name) {
9977                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9978                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9979                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9980                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9981                 }
9982                 if (r->manufacturer_url) {
9983                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9984                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9985                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9986                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9987                 }
9988                 if (r->hardware_id) {
9989                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9990                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9991                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9992                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9993                 }
9994                 if (r->provider) {
9995                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9996                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9997                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9998                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9999                 }
10000                 if (r->print_processor) {
10001                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
10002                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10003                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
10004                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10005                 }
10006                 if (r->vendor_setup) {
10007                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
10008                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10009                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
10010                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10011                 }
10012                 if (r->color_profiles) {
10013                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
10014                 }
10015                 if (r->inf_path) {
10016                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
10017                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10018                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
10019                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10020                 }
10021                 if (r->core_driver_dependencies) {
10022                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
10023                 }
10024         }
10025         return NDR_ERR_SUCCESS;
10026 }
10027
10028 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
10029 {
10030         uint32_t _ptr_driver_name;
10031         TALLOC_CTX *_mem_save_driver_name_0;
10032         uint32_t _ptr_architecture;
10033         TALLOC_CTX *_mem_save_architecture_0;
10034         uint32_t _ptr_driver_path;
10035         TALLOC_CTX *_mem_save_driver_path_0;
10036         uint32_t _ptr_data_file;
10037         TALLOC_CTX *_mem_save_data_file_0;
10038         uint32_t _ptr_config_file;
10039         TALLOC_CTX *_mem_save_config_file_0;
10040         uint32_t _ptr_help_file;
10041         TALLOC_CTX *_mem_save_help_file_0;
10042         uint32_t _ptr_monitor_name;
10043         TALLOC_CTX *_mem_save_monitor_name_0;
10044         uint32_t _ptr_default_datatype;
10045         TALLOC_CTX *_mem_save_default_datatype_0;
10046         uint32_t _ptr_dependent_files;
10047         TALLOC_CTX *_mem_save_dependent_files_0;
10048         uint32_t _ptr_previous_names;
10049         TALLOC_CTX *_mem_save_previous_names_0;
10050         uint32_t _ptr_manufacturer_name;
10051         TALLOC_CTX *_mem_save_manufacturer_name_0;
10052         uint32_t _ptr_manufacturer_url;
10053         TALLOC_CTX *_mem_save_manufacturer_url_0;
10054         uint32_t _ptr_hardware_id;
10055         TALLOC_CTX *_mem_save_hardware_id_0;
10056         uint32_t _ptr_provider;
10057         TALLOC_CTX *_mem_save_provider_0;
10058         uint32_t _ptr_print_processor;
10059         TALLOC_CTX *_mem_save_print_processor_0;
10060         uint32_t _ptr_vendor_setup;
10061         TALLOC_CTX *_mem_save_vendor_setup_0;
10062         uint32_t _ptr_color_profiles;
10063         TALLOC_CTX *_mem_save_color_profiles_0;
10064         uint32_t _ptr_inf_path;
10065         TALLOC_CTX *_mem_save_inf_path_0;
10066         uint32_t _ptr_core_driver_dependencies;
10067         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
10068         if (ndr_flags & NDR_SCALARS) {
10069                 NDR_CHECK(ndr_pull_align(ndr, 8));
10070                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10071                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10072                 if (_ptr_driver_name) {
10073                         NDR_PULL_ALLOC(ndr, r->driver_name);
10074                 } else {
10075                         r->driver_name = NULL;
10076                 }
10077                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10078                 if (_ptr_architecture) {
10079                         NDR_PULL_ALLOC(ndr, r->architecture);
10080                 } else {
10081                         r->architecture = NULL;
10082                 }
10083                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10084                 if (_ptr_driver_path) {
10085                         NDR_PULL_ALLOC(ndr, r->driver_path);
10086                 } else {
10087                         r->driver_path = NULL;
10088                 }
10089                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10090                 if (_ptr_data_file) {
10091                         NDR_PULL_ALLOC(ndr, r->data_file);
10092                 } else {
10093                         r->data_file = NULL;
10094                 }
10095                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10096                 if (_ptr_config_file) {
10097                         NDR_PULL_ALLOC(ndr, r->config_file);
10098                 } else {
10099                         r->config_file = NULL;
10100                 }
10101                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10102                 if (_ptr_help_file) {
10103                         NDR_PULL_ALLOC(ndr, r->help_file);
10104                 } else {
10105                         r->help_file = NULL;
10106                 }
10107                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10108                 if (_ptr_monitor_name) {
10109                         NDR_PULL_ALLOC(ndr, r->monitor_name);
10110                 } else {
10111                         r->monitor_name = NULL;
10112                 }
10113                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10114                 if (_ptr_default_datatype) {
10115                         NDR_PULL_ALLOC(ndr, r->default_datatype);
10116                 } else {
10117                         r->default_datatype = NULL;
10118                 }
10119                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
10120                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10121                 if (_ptr_dependent_files) {
10122                         NDR_PULL_ALLOC(ndr, r->dependent_files);
10123                 } else {
10124                         r->dependent_files = NULL;
10125                 }
10126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
10127                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
10128                 if (_ptr_previous_names) {
10129                         NDR_PULL_ALLOC(ndr, r->previous_names);
10130                 } else {
10131                         r->previous_names = NULL;
10132                 }
10133                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
10134                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
10135                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
10136                 if (_ptr_manufacturer_name) {
10137                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
10138                 } else {
10139                         r->manufacturer_name = NULL;
10140                 }
10141                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
10142                 if (_ptr_manufacturer_url) {
10143                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
10144                 } else {
10145                         r->manufacturer_url = NULL;
10146                 }
10147                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
10148                 if (_ptr_hardware_id) {
10149                         NDR_PULL_ALLOC(ndr, r->hardware_id);
10150                 } else {
10151                         r->hardware_id = NULL;
10152                 }
10153                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
10154                 if (_ptr_provider) {
10155                         NDR_PULL_ALLOC(ndr, r->provider);
10156                 } else {
10157                         r->provider = NULL;
10158                 }
10159                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
10160                 if (_ptr_print_processor) {
10161                         NDR_PULL_ALLOC(ndr, r->print_processor);
10162                 } else {
10163                         r->print_processor = NULL;
10164                 }
10165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
10166                 if (_ptr_vendor_setup) {
10167                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
10168                 } else {
10169                         r->vendor_setup = NULL;
10170                 }
10171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
10172                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
10173                 if (_ptr_color_profiles) {
10174                         NDR_PULL_ALLOC(ndr, r->color_profiles);
10175                 } else {
10176                         r->color_profiles = NULL;
10177                 }
10178                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
10179                 if (_ptr_inf_path) {
10180                         NDR_PULL_ALLOC(ndr, r->inf_path);
10181                 } else {
10182                         r->inf_path = NULL;
10183                 }
10184                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
10185                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
10186                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
10187                 if (_ptr_core_driver_dependencies) {
10188                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
10189                 } else {
10190                         r->core_driver_dependencies = NULL;
10191                 }
10192                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
10193                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
10194                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10195         }
10196         if (ndr_flags & NDR_BUFFERS) {
10197                 if (r->driver_name) {
10198                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10199                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10200                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
10201                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
10202                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
10203                                 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));
10204                         }
10205                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
10206                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
10207                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10208                 }
10209                 if (r->architecture) {
10210                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10211                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10212                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
10213                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
10214                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
10215                                 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));
10216                         }
10217                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
10218                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
10219                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10220                 }
10221                 if (r->driver_path) {
10222                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10223                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10224                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
10225                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
10226                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
10227                                 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));
10228                         }
10229                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
10230                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
10231                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10232                 }
10233                 if (r->data_file) {
10234                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10235                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10236                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
10237                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
10238                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
10239                                 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));
10240                         }
10241                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
10242                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
10243                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10244                 }
10245                 if (r->config_file) {
10246                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10247                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10248                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
10249                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
10250                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
10251                                 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));
10252                         }
10253                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
10254                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
10255                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10256                 }
10257                 if (r->help_file) {
10258                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10259                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10260                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
10261                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
10262                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
10263                                 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));
10264                         }
10265                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
10266                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
10267                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10268                 }
10269                 if (r->monitor_name) {
10270                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10271                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10272                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
10273                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
10274                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
10275                                 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));
10276                         }
10277                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
10278                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
10279                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10280                 }
10281                 if (r->default_datatype) {
10282                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10283                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10284                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
10285                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
10286                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
10287                                 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));
10288                         }
10289                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
10290                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
10291                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10292                 }
10293                 if (r->dependent_files) {
10294                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10295                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10296                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
10297                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10298                 }
10299                 if (r->previous_names) {
10300                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10301                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
10302                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
10303                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
10304                 }
10305                 if (r->manufacturer_name) {
10306                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10307                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
10308                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
10309                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
10310                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
10311                                 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));
10312                         }
10313                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
10314                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
10315                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
10316                 }
10317                 if (r->manufacturer_url) {
10318                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
10319                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
10320                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
10321                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
10322                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
10323                                 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));
10324                         }
10325                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
10326                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
10327                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
10328                 }
10329                 if (r->hardware_id) {
10330                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
10331                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
10332                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
10333                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
10334                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
10335                                 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));
10336                         }
10337                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
10338                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
10339                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
10340                 }
10341                 if (r->provider) {
10342                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
10343                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
10344                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
10345                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
10346                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
10347                                 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));
10348                         }
10349                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
10350                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
10351                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
10352                 }
10353                 if (r->print_processor) {
10354                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
10355                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
10356                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
10357                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
10358                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
10359                                 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));
10360                         }
10361                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
10362                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
10363                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
10364                 }
10365                 if (r->vendor_setup) {
10366                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
10367                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
10368                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
10369                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
10370                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
10371                                 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));
10372                         }
10373                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
10374                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
10375                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
10376                 }
10377                 if (r->color_profiles) {
10378                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
10379                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
10380                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
10381                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
10382                 }
10383                 if (r->inf_path) {
10384                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10385                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
10386                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
10387                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
10388                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
10389                                 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));
10390                         }
10391                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
10392                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
10393                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
10394                 }
10395                 if (r->core_driver_dependencies) {
10396                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
10397                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
10398                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
10399                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
10400                 }
10401         }
10402         return NDR_ERR_SUCCESS;
10403 }
10404
10405 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
10406 {
10407         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
10408         ndr->depth++;
10409         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10410         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10411         ndr->depth++;
10412         if (r->driver_name) {
10413                 ndr_print_string(ndr, "driver_name", r->driver_name);
10414         }
10415         ndr->depth--;
10416         ndr_print_ptr(ndr, "architecture", r->architecture);
10417         ndr->depth++;
10418         if (r->architecture) {
10419                 ndr_print_string(ndr, "architecture", r->architecture);
10420         }
10421         ndr->depth--;
10422         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10423         ndr->depth++;
10424         if (r->driver_path) {
10425                 ndr_print_string(ndr, "driver_path", r->driver_path);
10426         }
10427         ndr->depth--;
10428         ndr_print_ptr(ndr, "data_file", r->data_file);
10429         ndr->depth++;
10430         if (r->data_file) {
10431                 ndr_print_string(ndr, "data_file", r->data_file);
10432         }
10433         ndr->depth--;
10434         ndr_print_ptr(ndr, "config_file", r->config_file);
10435         ndr->depth++;
10436         if (r->config_file) {
10437                 ndr_print_string(ndr, "config_file", r->config_file);
10438         }
10439         ndr->depth--;
10440         ndr_print_ptr(ndr, "help_file", r->help_file);
10441         ndr->depth++;
10442         if (r->help_file) {
10443                 ndr_print_string(ndr, "help_file", r->help_file);
10444         }
10445         ndr->depth--;
10446         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10447         ndr->depth++;
10448         if (r->monitor_name) {
10449                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10450         }
10451         ndr->depth--;
10452         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10453         ndr->depth++;
10454         if (r->default_datatype) {
10455                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10456         }
10457         ndr->depth--;
10458         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);
10459         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10460         ndr->depth++;
10461         if (r->dependent_files) {
10462                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
10463         }
10464         ndr->depth--;
10465         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);
10466         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10467         ndr->depth++;
10468         if (r->previous_names) {
10469                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
10470         }
10471         ndr->depth--;
10472         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
10473         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10474         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10475         ndr->depth++;
10476         if (r->manufacturer_name) {
10477                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10478         }
10479         ndr->depth--;
10480         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10481         ndr->depth++;
10482         if (r->manufacturer_url) {
10483                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10484         }
10485         ndr->depth--;
10486         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10487         ndr->depth++;
10488         if (r->hardware_id) {
10489                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10490         }
10491         ndr->depth--;
10492         ndr_print_ptr(ndr, "provider", r->provider);
10493         ndr->depth++;
10494         if (r->provider) {
10495                 ndr_print_string(ndr, "provider", r->provider);
10496         }
10497         ndr->depth--;
10498         ndr_print_ptr(ndr, "print_processor", r->print_processor);
10499         ndr->depth++;
10500         if (r->print_processor) {
10501                 ndr_print_string(ndr, "print_processor", r->print_processor);
10502         }
10503         ndr->depth--;
10504         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
10505         ndr->depth++;
10506         if (r->vendor_setup) {
10507                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
10508         }
10509         ndr->depth--;
10510         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);
10511         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
10512         ndr->depth++;
10513         if (r->color_profiles) {
10514                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
10515         }
10516         ndr->depth--;
10517         ndr_print_ptr(ndr, "inf_path", r->inf_path);
10518         ndr->depth++;
10519         if (r->inf_path) {
10520                 ndr_print_string(ndr, "inf_path", r->inf_path);
10521         }
10522         ndr->depth--;
10523         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
10524         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);
10525         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10526         ndr->depth++;
10527         if (r->core_driver_dependencies) {
10528                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10529         }
10530         ndr->depth--;
10531         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
10532         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
10533         ndr->depth--;
10534 }
10535
10536 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
10537 {
10538         if (ndr_flags & NDR_SCALARS) {
10539                 int level = ndr_push_get_switch_value(ndr, r);
10540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
10541                 NDR_CHECK(ndr_push_union_align(ndr, 5));
10542                 switch (level) {
10543                         case 1: {
10544                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
10545                         break; }
10546
10547                         case 2: {
10548                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
10549                         break; }
10550
10551                         case 3: {
10552                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
10553                         break; }
10554
10555                         case 4: {
10556                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
10557                         break; }
10558
10559                         case 6: {
10560                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
10561                         break; }
10562
10563                         case 8: {
10564                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
10565                         break; }
10566
10567                         default:
10568                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10569                 }
10570         }
10571         if (ndr_flags & NDR_BUFFERS) {
10572                 int level = ndr_push_get_switch_value(ndr, r);
10573                 switch (level) {
10574                         case 1:
10575                                 if (r->info1) {
10576                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10577                                 }
10578                         break;
10579
10580                         case 2:
10581                                 if (r->info2) {
10582                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10583                                 }
10584                         break;
10585
10586                         case 3:
10587                                 if (r->info3) {
10588                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10589                                 }
10590                         break;
10591
10592                         case 4:
10593                                 if (r->info4) {
10594                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10595                                 }
10596                         break;
10597
10598                         case 6:
10599                                 if (r->info6) {
10600                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10601                                 }
10602                         break;
10603
10604                         case 8:
10605                                 if (r->info8) {
10606                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10607                                 }
10608                         break;
10609
10610                         default:
10611                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10612                 }
10613         }
10614         return NDR_ERR_SUCCESS;
10615 }
10616
10617 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
10618 {
10619         int level;
10620         uint32_t _level;
10621         TALLOC_CTX *_mem_save_info1_0;
10622         TALLOC_CTX *_mem_save_info2_0;
10623         TALLOC_CTX *_mem_save_info3_0;
10624         TALLOC_CTX *_mem_save_info4_0;
10625         TALLOC_CTX *_mem_save_info6_0;
10626         TALLOC_CTX *_mem_save_info8_0;
10627         level = ndr_pull_get_switch_value(ndr, r);
10628         if (ndr_flags & NDR_SCALARS) {
10629                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
10630                 if (_level != level) {
10631                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10632                 }
10633                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
10634                 switch (level) {
10635                         case 1: {
10636                                 uint32_t _ptr_info1;
10637                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
10638                                 if (_ptr_info1) {
10639                                         NDR_PULL_ALLOC(ndr, r->info1);
10640                                 } else {
10641                                         r->info1 = NULL;
10642                                 }
10643                         break; }
10644
10645                         case 2: {
10646                                 uint32_t _ptr_info2;
10647                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
10648                                 if (_ptr_info2) {
10649                                         NDR_PULL_ALLOC(ndr, r->info2);
10650                                 } else {
10651                                         r->info2 = NULL;
10652                                 }
10653                         break; }
10654
10655                         case 3: {
10656                                 uint32_t _ptr_info3;
10657                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
10658                                 if (_ptr_info3) {
10659                                         NDR_PULL_ALLOC(ndr, r->info3);
10660                                 } else {
10661                                         r->info3 = NULL;
10662                                 }
10663                         break; }
10664
10665                         case 4: {
10666                                 uint32_t _ptr_info4;
10667                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
10668                                 if (_ptr_info4) {
10669                                         NDR_PULL_ALLOC(ndr, r->info4);
10670                                 } else {
10671                                         r->info4 = NULL;
10672                                 }
10673                         break; }
10674
10675                         case 6: {
10676                                 uint32_t _ptr_info6;
10677                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
10678                                 if (_ptr_info6) {
10679                                         NDR_PULL_ALLOC(ndr, r->info6);
10680                                 } else {
10681                                         r->info6 = NULL;
10682                                 }
10683                         break; }
10684
10685                         case 8: {
10686                                 uint32_t _ptr_info8;
10687                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
10688                                 if (_ptr_info8) {
10689                                         NDR_PULL_ALLOC(ndr, r->info8);
10690                                 } else {
10691                                         r->info8 = NULL;
10692                                 }
10693                         break; }
10694
10695                         default:
10696                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10697                 }
10698         }
10699         if (ndr_flags & NDR_BUFFERS) {
10700                 switch (level) {
10701                         case 1:
10702                                 if (r->info1) {
10703                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
10704                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
10705                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10706                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
10707                                 }
10708                         break;
10709
10710                         case 2:
10711                                 if (r->info2) {
10712                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
10713                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
10714                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10715                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
10716                                 }
10717                         break;
10718
10719                         case 3:
10720                                 if (r->info3) {
10721                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
10722                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
10723                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10724                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
10725                                 }
10726                         break;
10727
10728                         case 4:
10729                                 if (r->info4) {
10730                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
10731                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
10732                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10733                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
10734                                 }
10735                         break;
10736
10737                         case 6:
10738                                 if (r->info6) {
10739                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
10740                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
10741                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10742                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
10743                                 }
10744                         break;
10745
10746                         case 8:
10747                                 if (r->info8) {
10748                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
10749                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
10750                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10751                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
10752                                 }
10753                         break;
10754
10755                         default:
10756                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10757                 }
10758         }
10759         return NDR_ERR_SUCCESS;
10760 }
10761
10762 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
10763 {
10764         int level;
10765         level = ndr_print_get_switch_value(ndr, r);
10766         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
10767         switch (level) {
10768                 case 1:
10769                         ndr_print_ptr(ndr, "info1", r->info1);
10770                         ndr->depth++;
10771                         if (r->info1) {
10772                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
10773                         }
10774                         ndr->depth--;
10775                 break;
10776
10777                 case 2:
10778                         ndr_print_ptr(ndr, "info2", r->info2);
10779                         ndr->depth++;
10780                         if (r->info2) {
10781                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
10782                         }
10783                         ndr->depth--;
10784                 break;
10785
10786                 case 3:
10787                         ndr_print_ptr(ndr, "info3", r->info3);
10788                         ndr->depth++;
10789                         if (r->info3) {
10790                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
10791                         }
10792                         ndr->depth--;
10793                 break;
10794
10795                 case 4:
10796                         ndr_print_ptr(ndr, "info4", r->info4);
10797                         ndr->depth++;
10798                         if (r->info4) {
10799                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
10800                         }
10801                         ndr->depth--;
10802                 break;
10803
10804                 case 6:
10805                         ndr_print_ptr(ndr, "info6", r->info6);
10806                         ndr->depth++;
10807                         if (r->info6) {
10808                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
10809                         }
10810                         ndr->depth--;
10811                 break;
10812
10813                 case 8:
10814                         ndr_print_ptr(ndr, "info8", r->info8);
10815                         ndr->depth++;
10816                         if (r->info8) {
10817                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
10818                         }
10819                         ndr->depth--;
10820                 break;
10821
10822                 default:
10823                         ndr_print_bad_level(ndr, name, level);
10824         }
10825 }
10826
10827 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
10828 {
10829         if (ndr_flags & NDR_SCALARS) {
10830                 NDR_CHECK(ndr_push_align(ndr, 5));
10831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
10832                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
10833                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10834                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10835         }
10836         if (ndr_flags & NDR_BUFFERS) {
10837                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10838         }
10839         return NDR_ERR_SUCCESS;
10840 }
10841
10842 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
10843 {
10844         if (ndr_flags & NDR_SCALARS) {
10845                 NDR_CHECK(ndr_pull_align(ndr, 5));
10846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
10847                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
10848                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10849                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10850         }
10851         if (ndr_flags & NDR_BUFFERS) {
10852                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10853         }
10854         return NDR_ERR_SUCCESS;
10855 }
10856
10857 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
10858 {
10859         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
10860         ndr->depth++;
10861         ndr_print_uint32(ndr, "level", r->level);
10862         ndr_print_set_switch_value(ndr, &r->info, r->level);
10863         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
10864         ndr->depth--;
10865 }
10866
10867 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
10868 {
10869         if (ndr_flags & NDR_SCALARS) {
10870                 NDR_CHECK(ndr_push_align(ndr, 5));
10871                 {
10872                         uint32_t _flags_save_string = ndr->flags;
10873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10874                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10875                         ndr->flags = _flags_save_string;
10876                 }
10877                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10878         }
10879         if (ndr_flags & NDR_BUFFERS) {
10880                 {
10881                         uint32_t _flags_save_string = ndr->flags;
10882                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10883                         if (r->driver_name) {
10884                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
10885                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10886                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
10887                         }
10888                         ndr->flags = _flags_save_string;
10889                 }
10890         }
10891         return NDR_ERR_SUCCESS;
10892 }
10893
10894 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
10895 {
10896         uint32_t _ptr_driver_name;
10897         TALLOC_CTX *_mem_save_driver_name_0;
10898         if (ndr_flags & NDR_SCALARS) {
10899                 NDR_CHECK(ndr_pull_align(ndr, 5));
10900                 {
10901                         uint32_t _flags_save_string = ndr->flags;
10902                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10903                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10904                         if (_ptr_driver_name) {
10905                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10906                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10907                         } else {
10908                                 r->driver_name = NULL;
10909                         }
10910                         ndr->flags = _flags_save_string;
10911                 }
10912                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10913         }
10914         if (ndr_flags & NDR_BUFFERS) {
10915                 {
10916                         uint32_t _flags_save_string = ndr->flags;
10917                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10918                         if (r->driver_name) {
10919                                 uint32_t _relative_save_offset;
10920                                 _relative_save_offset = ndr->offset;
10921                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10922                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10923                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10924                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10925                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10926                                 if (ndr->offset > ndr->relative_highest_offset) {
10927                                         ndr->relative_highest_offset = ndr->offset;
10928                                 }
10929                                 ndr->offset = _relative_save_offset;
10930                         }
10931                         ndr->flags = _flags_save_string;
10932                 }
10933         }
10934         return NDR_ERR_SUCCESS;
10935 }
10936
10937 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
10938 {
10939         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
10940         ndr->depth++;
10941         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10942         ndr->depth++;
10943         if (r->driver_name) {
10944                 ndr_print_string(ndr, "driver_name", r->driver_name);
10945         }
10946         ndr->depth--;
10947         ndr->depth--;
10948 }
10949
10950 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
10951 {
10952         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
10953 }
10954
10955 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
10956 {
10957         if (ndr_flags & NDR_SCALARS) {
10958                 NDR_CHECK(ndr_push_align(ndr, 5));
10959                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10960                 {
10961                         uint32_t _flags_save_string = ndr->flags;
10962                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10963                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10964                         ndr->flags = _flags_save_string;
10965                 }
10966                 {
10967                         uint32_t _flags_save_string = ndr->flags;
10968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10969                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10970                         ndr->flags = _flags_save_string;
10971                 }
10972                 {
10973                         uint32_t _flags_save_string = ndr->flags;
10974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10975                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10976                         ndr->flags = _flags_save_string;
10977                 }
10978                 {
10979                         uint32_t _flags_save_string = ndr->flags;
10980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10981                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10982                         ndr->flags = _flags_save_string;
10983                 }
10984                 {
10985                         uint32_t _flags_save_string = ndr->flags;
10986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10987                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10988                         ndr->flags = _flags_save_string;
10989                 }
10990                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10991         }
10992         if (ndr_flags & NDR_BUFFERS) {
10993                 {
10994                         uint32_t _flags_save_string = ndr->flags;
10995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10996                         if (r->driver_name) {
10997                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
10998                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10999                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
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->architecture) {
11007                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
11008                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11009                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
11010                         }
11011                         ndr->flags = _flags_save_string;
11012                 }
11013                 {
11014                         uint32_t _flags_save_string = ndr->flags;
11015                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11016                         if (r->driver_path) {
11017                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
11018                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11019                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
11020                         }
11021                         ndr->flags = _flags_save_string;
11022                 }
11023                 {
11024                         uint32_t _flags_save_string = ndr->flags;
11025                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11026                         if (r->data_file) {
11027                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
11028                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11029                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
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                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
11038                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11039                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
11040                         }
11041                         ndr->flags = _flags_save_string;
11042                 }
11043         }
11044         return NDR_ERR_SUCCESS;
11045 }
11046
11047 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
11048 {
11049         uint32_t _ptr_driver_name;
11050         TALLOC_CTX *_mem_save_driver_name_0;
11051         uint32_t _ptr_architecture;
11052         TALLOC_CTX *_mem_save_architecture_0;
11053         uint32_t _ptr_driver_path;
11054         TALLOC_CTX *_mem_save_driver_path_0;
11055         uint32_t _ptr_data_file;
11056         TALLOC_CTX *_mem_save_data_file_0;
11057         uint32_t _ptr_config_file;
11058         TALLOC_CTX *_mem_save_config_file_0;
11059         if (ndr_flags & NDR_SCALARS) {
11060                 NDR_CHECK(ndr_pull_align(ndr, 5));
11061                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11062                 {
11063                         uint32_t _flags_save_string = ndr->flags;
11064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11065                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11066                         if (_ptr_driver_name) {
11067                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11068                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11069                         } else {
11070                                 r->driver_name = NULL;
11071                         }
11072                         ndr->flags = _flags_save_string;
11073                 }
11074                 {
11075                         uint32_t _flags_save_string = ndr->flags;
11076                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11077                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11078                         if (_ptr_architecture) {
11079                                 NDR_PULL_ALLOC(ndr, r->architecture);
11080                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11081                         } else {
11082                                 r->architecture = NULL;
11083                         }
11084                         ndr->flags = _flags_save_string;
11085                 }
11086                 {
11087                         uint32_t _flags_save_string = ndr->flags;
11088                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11089                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11090                         if (_ptr_driver_path) {
11091                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11092                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11093                         } else {
11094                                 r->driver_path = NULL;
11095                         }
11096                         ndr->flags = _flags_save_string;
11097                 }
11098                 {
11099                         uint32_t _flags_save_string = ndr->flags;
11100                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11101                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11102                         if (_ptr_data_file) {
11103                                 NDR_PULL_ALLOC(ndr, r->data_file);
11104                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11105                         } else {
11106                                 r->data_file = NULL;
11107                         }
11108                         ndr->flags = _flags_save_string;
11109                 }
11110                 {
11111                         uint32_t _flags_save_string = ndr->flags;
11112                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11113                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11114                         if (_ptr_config_file) {
11115                                 NDR_PULL_ALLOC(ndr, r->config_file);
11116                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11117                         } else {
11118                                 r->config_file = NULL;
11119                         }
11120                         ndr->flags = _flags_save_string;
11121                 }
11122                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11123         }
11124         if (ndr_flags & NDR_BUFFERS) {
11125                 {
11126                         uint32_t _flags_save_string = ndr->flags;
11127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11128                         if (r->driver_name) {
11129                                 uint32_t _relative_save_offset;
11130                                 _relative_save_offset = ndr->offset;
11131                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11132                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11133                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11134                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11135                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11136                                 if (ndr->offset > ndr->relative_highest_offset) {
11137                                         ndr->relative_highest_offset = ndr->offset;
11138                                 }
11139                                 ndr->offset = _relative_save_offset;
11140                         }
11141                         ndr->flags = _flags_save_string;
11142                 }
11143                 {
11144                         uint32_t _flags_save_string = ndr->flags;
11145                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11146                         if (r->architecture) {
11147                                 uint32_t _relative_save_offset;
11148                                 _relative_save_offset = ndr->offset;
11149                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11150                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11151                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11152                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11153                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11154                                 if (ndr->offset > ndr->relative_highest_offset) {
11155                                         ndr->relative_highest_offset = ndr->offset;
11156                                 }
11157                                 ndr->offset = _relative_save_offset;
11158                         }
11159                         ndr->flags = _flags_save_string;
11160                 }
11161                 {
11162                         uint32_t _flags_save_string = ndr->flags;
11163                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11164                         if (r->driver_path) {
11165                                 uint32_t _relative_save_offset;
11166                                 _relative_save_offset = ndr->offset;
11167                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11168                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11169                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11170                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11171                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11172                                 if (ndr->offset > ndr->relative_highest_offset) {
11173                                         ndr->relative_highest_offset = ndr->offset;
11174                                 }
11175                                 ndr->offset = _relative_save_offset;
11176                         }
11177                         ndr->flags = _flags_save_string;
11178                 }
11179                 {
11180                         uint32_t _flags_save_string = ndr->flags;
11181                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11182                         if (r->data_file) {
11183                                 uint32_t _relative_save_offset;
11184                                 _relative_save_offset = ndr->offset;
11185                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11186                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11187                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11188                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11189                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11190                                 if (ndr->offset > ndr->relative_highest_offset) {
11191                                         ndr->relative_highest_offset = ndr->offset;
11192                                 }
11193                                 ndr->offset = _relative_save_offset;
11194                         }
11195                         ndr->flags = _flags_save_string;
11196                 }
11197                 {
11198                         uint32_t _flags_save_string = ndr->flags;
11199                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11200                         if (r->config_file) {
11201                                 uint32_t _relative_save_offset;
11202                                 _relative_save_offset = ndr->offset;
11203                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11204                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11205                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11206                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11207                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11208                                 if (ndr->offset > ndr->relative_highest_offset) {
11209                                         ndr->relative_highest_offset = ndr->offset;
11210                                 }
11211                                 ndr->offset = _relative_save_offset;
11212                         }
11213                         ndr->flags = _flags_save_string;
11214                 }
11215         }
11216         return NDR_ERR_SUCCESS;
11217 }
11218
11219 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
11220 {
11221         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
11222         ndr->depth++;
11223         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11224         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11225         ndr->depth++;
11226         if (r->driver_name) {
11227                 ndr_print_string(ndr, "driver_name", r->driver_name);
11228         }
11229         ndr->depth--;
11230         ndr_print_ptr(ndr, "architecture", r->architecture);
11231         ndr->depth++;
11232         if (r->architecture) {
11233                 ndr_print_string(ndr, "architecture", r->architecture);
11234         }
11235         ndr->depth--;
11236         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11237         ndr->depth++;
11238         if (r->driver_path) {
11239                 ndr_print_string(ndr, "driver_path", r->driver_path);
11240         }
11241         ndr->depth--;
11242         ndr_print_ptr(ndr, "data_file", r->data_file);
11243         ndr->depth++;
11244         if (r->data_file) {
11245                 ndr_print_string(ndr, "data_file", r->data_file);
11246         }
11247         ndr->depth--;
11248         ndr_print_ptr(ndr, "config_file", r->config_file);
11249         ndr->depth++;
11250         if (r->config_file) {
11251                 ndr_print_string(ndr, "config_file", r->config_file);
11252         }
11253         ndr->depth--;
11254         ndr->depth--;
11255 }
11256
11257 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
11258 {
11259         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
11260 }
11261
11262 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
11263 {
11264         if (ndr_flags & NDR_SCALARS) {
11265                 NDR_CHECK(ndr_push_align(ndr, 5));
11266                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11267                 {
11268                         uint32_t _flags_save_string = ndr->flags;
11269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11270                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11277                         ndr->flags = _flags_save_string;
11278                 }
11279                 {
11280                         uint32_t _flags_save_string = ndr->flags;
11281                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11282                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11283                         ndr->flags = _flags_save_string;
11284                 }
11285                 {
11286                         uint32_t _flags_save_string = ndr->flags;
11287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11288                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11295                         ndr->flags = _flags_save_string;
11296                 }
11297                 {
11298                         uint32_t _flags_save_string = ndr->flags;
11299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11300                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11301                         ndr->flags = _flags_save_string;
11302                 }
11303                 {
11304                         uint32_t _flags_save_string_array = ndr->flags;
11305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11306                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11313                         ndr->flags = _flags_save_string;
11314                 }
11315                 {
11316                         uint32_t _flags_save_string = ndr->flags;
11317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11318                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11319                         ndr->flags = _flags_save_string;
11320                 }
11321                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11322         }
11323         if (ndr_flags & NDR_BUFFERS) {
11324                 {
11325                         uint32_t _flags_save_string = ndr->flags;
11326                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11327                         if (r->driver_name) {
11328                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
11329                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11330                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
11331                         }
11332                         ndr->flags = _flags_save_string;
11333                 }
11334                 {
11335                         uint32_t _flags_save_string = ndr->flags;
11336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11337                         if (r->architecture) {
11338                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
11339                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11340                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
11341                         }
11342                         ndr->flags = _flags_save_string;
11343                 }
11344                 {
11345                         uint32_t _flags_save_string = ndr->flags;
11346                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11347                         if (r->driver_path) {
11348                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
11349                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11350                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
11351                         }
11352                         ndr->flags = _flags_save_string;
11353                 }
11354                 {
11355                         uint32_t _flags_save_string = ndr->flags;
11356                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11357                         if (r->data_file) {
11358                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
11359                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11360                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
11361                         }
11362                         ndr->flags = _flags_save_string;
11363                 }
11364                 {
11365                         uint32_t _flags_save_string = ndr->flags;
11366                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11367                         if (r->config_file) {
11368                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
11369                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11370                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
11371                         }
11372                         ndr->flags = _flags_save_string;
11373                 }
11374                 {
11375                         uint32_t _flags_save_string = ndr->flags;
11376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11377                         if (r->help_file) {
11378                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
11379                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11380                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
11381                         }
11382                         ndr->flags = _flags_save_string;
11383                 }
11384                 {
11385                         uint32_t _flags_save_string_array = ndr->flags;
11386                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11387                         if (r->dependent_files) {
11388                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
11389                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11390                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
11391                         }
11392                         ndr->flags = _flags_save_string_array;
11393                 }
11394                 {
11395                         uint32_t _flags_save_string = ndr->flags;
11396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11397                         if (r->monitor_name) {
11398                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
11399                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11400                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
11401                         }
11402                         ndr->flags = _flags_save_string;
11403                 }
11404                 {
11405                         uint32_t _flags_save_string = ndr->flags;
11406                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11407                         if (r->default_datatype) {
11408                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
11409                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11410                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
11411                         }
11412                         ndr->flags = _flags_save_string;
11413                 }
11414         }
11415         return NDR_ERR_SUCCESS;
11416 }
11417
11418 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
11419 {
11420         uint32_t _ptr_driver_name;
11421         TALLOC_CTX *_mem_save_driver_name_0;
11422         uint32_t _ptr_architecture;
11423         TALLOC_CTX *_mem_save_architecture_0;
11424         uint32_t _ptr_driver_path;
11425         TALLOC_CTX *_mem_save_driver_path_0;
11426         uint32_t _ptr_data_file;
11427         TALLOC_CTX *_mem_save_data_file_0;
11428         uint32_t _ptr_config_file;
11429         TALLOC_CTX *_mem_save_config_file_0;
11430         uint32_t _ptr_help_file;
11431         TALLOC_CTX *_mem_save_help_file_0;
11432         uint32_t _ptr_dependent_files;
11433         TALLOC_CTX *_mem_save_dependent_files_0;
11434         uint32_t _ptr_monitor_name;
11435         TALLOC_CTX *_mem_save_monitor_name_0;
11436         uint32_t _ptr_default_datatype;
11437         TALLOC_CTX *_mem_save_default_datatype_0;
11438         if (ndr_flags & NDR_SCALARS) {
11439                 NDR_CHECK(ndr_pull_align(ndr, 5));
11440                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11441                 {
11442                         uint32_t _flags_save_string = ndr->flags;
11443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11444                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11445                         if (_ptr_driver_name) {
11446                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11447                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11448                         } else {
11449                                 r->driver_name = NULL;
11450                         }
11451                         ndr->flags = _flags_save_string;
11452                 }
11453                 {
11454                         uint32_t _flags_save_string = ndr->flags;
11455                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11456                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11457                         if (_ptr_architecture) {
11458                                 NDR_PULL_ALLOC(ndr, r->architecture);
11459                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11460                         } else {
11461                                 r->architecture = NULL;
11462                         }
11463                         ndr->flags = _flags_save_string;
11464                 }
11465                 {
11466                         uint32_t _flags_save_string = ndr->flags;
11467                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11468                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11469                         if (_ptr_driver_path) {
11470                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11471                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11472                         } else {
11473                                 r->driver_path = NULL;
11474                         }
11475                         ndr->flags = _flags_save_string;
11476                 }
11477                 {
11478                         uint32_t _flags_save_string = ndr->flags;
11479                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11480                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11481                         if (_ptr_data_file) {
11482                                 NDR_PULL_ALLOC(ndr, r->data_file);
11483                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11484                         } else {
11485                                 r->data_file = NULL;
11486                         }
11487                         ndr->flags = _flags_save_string;
11488                 }
11489                 {
11490                         uint32_t _flags_save_string = ndr->flags;
11491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11492                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11493                         if (_ptr_config_file) {
11494                                 NDR_PULL_ALLOC(ndr, r->config_file);
11495                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11496                         } else {
11497                                 r->config_file = NULL;
11498                         }
11499                         ndr->flags = _flags_save_string;
11500                 }
11501                 {
11502                         uint32_t _flags_save_string = ndr->flags;
11503                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11504                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11505                         if (_ptr_help_file) {
11506                                 NDR_PULL_ALLOC(ndr, r->help_file);
11507                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11508                         } else {
11509                                 r->help_file = NULL;
11510                         }
11511                         ndr->flags = _flags_save_string;
11512                 }
11513                 {
11514                         uint32_t _flags_save_string_array = ndr->flags;
11515                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11516                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11517                         if (_ptr_dependent_files) {
11518                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11519                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11520                         } else {
11521                                 r->dependent_files = NULL;
11522                         }
11523                         ndr->flags = _flags_save_string_array;
11524                 }
11525                 {
11526                         uint32_t _flags_save_string = ndr->flags;
11527                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11528                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11529                         if (_ptr_monitor_name) {
11530                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11531                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11532                         } else {
11533                                 r->monitor_name = NULL;
11534                         }
11535                         ndr->flags = _flags_save_string;
11536                 }
11537                 {
11538                         uint32_t _flags_save_string = ndr->flags;
11539                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11540                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11541                         if (_ptr_default_datatype) {
11542                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11543                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11544                         } else {
11545                                 r->default_datatype = NULL;
11546                         }
11547                         ndr->flags = _flags_save_string;
11548                 }
11549                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11550         }
11551         if (ndr_flags & NDR_BUFFERS) {
11552                 {
11553                         uint32_t _flags_save_string = ndr->flags;
11554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11555                         if (r->driver_name) {
11556                                 uint32_t _relative_save_offset;
11557                                 _relative_save_offset = ndr->offset;
11558                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11559                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11560                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11561                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11562                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11563                                 if (ndr->offset > ndr->relative_highest_offset) {
11564                                         ndr->relative_highest_offset = ndr->offset;
11565                                 }
11566                                 ndr->offset = _relative_save_offset;
11567                         }
11568                         ndr->flags = _flags_save_string;
11569                 }
11570                 {
11571                         uint32_t _flags_save_string = ndr->flags;
11572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11573                         if (r->architecture) {
11574                                 uint32_t _relative_save_offset;
11575                                 _relative_save_offset = ndr->offset;
11576                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11577                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11578                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11579                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11580                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11581                                 if (ndr->offset > ndr->relative_highest_offset) {
11582                                         ndr->relative_highest_offset = ndr->offset;
11583                                 }
11584                                 ndr->offset = _relative_save_offset;
11585                         }
11586                         ndr->flags = _flags_save_string;
11587                 }
11588                 {
11589                         uint32_t _flags_save_string = ndr->flags;
11590                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11591                         if (r->driver_path) {
11592                                 uint32_t _relative_save_offset;
11593                                 _relative_save_offset = ndr->offset;
11594                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11595                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11596                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11597                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11598                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11599                                 if (ndr->offset > ndr->relative_highest_offset) {
11600                                         ndr->relative_highest_offset = ndr->offset;
11601                                 }
11602                                 ndr->offset = _relative_save_offset;
11603                         }
11604                         ndr->flags = _flags_save_string;
11605                 }
11606                 {
11607                         uint32_t _flags_save_string = ndr->flags;
11608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11609                         if (r->data_file) {
11610                                 uint32_t _relative_save_offset;
11611                                 _relative_save_offset = ndr->offset;
11612                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11613                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11614                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11615                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11616                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11617                                 if (ndr->offset > ndr->relative_highest_offset) {
11618                                         ndr->relative_highest_offset = ndr->offset;
11619                                 }
11620                                 ndr->offset = _relative_save_offset;
11621                         }
11622                         ndr->flags = _flags_save_string;
11623                 }
11624                 {
11625                         uint32_t _flags_save_string = ndr->flags;
11626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11627                         if (r->config_file) {
11628                                 uint32_t _relative_save_offset;
11629                                 _relative_save_offset = ndr->offset;
11630                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11631                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11632                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11633                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11634                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11635                                 if (ndr->offset > ndr->relative_highest_offset) {
11636                                         ndr->relative_highest_offset = ndr->offset;
11637                                 }
11638                                 ndr->offset = _relative_save_offset;
11639                         }
11640                         ndr->flags = _flags_save_string;
11641                 }
11642                 {
11643                         uint32_t _flags_save_string = ndr->flags;
11644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11645                         if (r->help_file) {
11646                                 uint32_t _relative_save_offset;
11647                                 _relative_save_offset = ndr->offset;
11648                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11649                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11650                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11651                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11652                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11653                                 if (ndr->offset > ndr->relative_highest_offset) {
11654                                         ndr->relative_highest_offset = ndr->offset;
11655                                 }
11656                                 ndr->offset = _relative_save_offset;
11657                         }
11658                         ndr->flags = _flags_save_string;
11659                 }
11660                 {
11661                         uint32_t _flags_save_string_array = ndr->flags;
11662                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11663                         if (r->dependent_files) {
11664                                 uint32_t _relative_save_offset;
11665                                 _relative_save_offset = ndr->offset;
11666                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11667                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11668                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11669                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11670                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11671                                 if (ndr->offset > ndr->relative_highest_offset) {
11672                                         ndr->relative_highest_offset = ndr->offset;
11673                                 }
11674                                 ndr->offset = _relative_save_offset;
11675                         }
11676                         ndr->flags = _flags_save_string_array;
11677                 }
11678                 {
11679                         uint32_t _flags_save_string = ndr->flags;
11680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11681                         if (r->monitor_name) {
11682                                 uint32_t _relative_save_offset;
11683                                 _relative_save_offset = ndr->offset;
11684                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11685                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11686                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11687                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11688                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11689                                 if (ndr->offset > ndr->relative_highest_offset) {
11690                                         ndr->relative_highest_offset = ndr->offset;
11691                                 }
11692                                 ndr->offset = _relative_save_offset;
11693                         }
11694                         ndr->flags = _flags_save_string;
11695                 }
11696                 {
11697                         uint32_t _flags_save_string = ndr->flags;
11698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11699                         if (r->default_datatype) {
11700                                 uint32_t _relative_save_offset;
11701                                 _relative_save_offset = ndr->offset;
11702                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11703                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11704                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11705                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11706                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11707                                 if (ndr->offset > ndr->relative_highest_offset) {
11708                                         ndr->relative_highest_offset = ndr->offset;
11709                                 }
11710                                 ndr->offset = _relative_save_offset;
11711                         }
11712                         ndr->flags = _flags_save_string;
11713                 }
11714         }
11715         return NDR_ERR_SUCCESS;
11716 }
11717
11718 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
11719 {
11720         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
11721         ndr->depth++;
11722         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11723         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11724         ndr->depth++;
11725         if (r->driver_name) {
11726                 ndr_print_string(ndr, "driver_name", r->driver_name);
11727         }
11728         ndr->depth--;
11729         ndr_print_ptr(ndr, "architecture", r->architecture);
11730         ndr->depth++;
11731         if (r->architecture) {
11732                 ndr_print_string(ndr, "architecture", r->architecture);
11733         }
11734         ndr->depth--;
11735         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11736         ndr->depth++;
11737         if (r->driver_path) {
11738                 ndr_print_string(ndr, "driver_path", r->driver_path);
11739         }
11740         ndr->depth--;
11741         ndr_print_ptr(ndr, "data_file", r->data_file);
11742         ndr->depth++;
11743         if (r->data_file) {
11744                 ndr_print_string(ndr, "data_file", r->data_file);
11745         }
11746         ndr->depth--;
11747         ndr_print_ptr(ndr, "config_file", r->config_file);
11748         ndr->depth++;
11749         if (r->config_file) {
11750                 ndr_print_string(ndr, "config_file", r->config_file);
11751         }
11752         ndr->depth--;
11753         ndr_print_ptr(ndr, "help_file", r->help_file);
11754         ndr->depth++;
11755         if (r->help_file) {
11756                 ndr_print_string(ndr, "help_file", r->help_file);
11757         }
11758         ndr->depth--;
11759         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11760         ndr->depth++;
11761         if (r->dependent_files) {
11762                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11763         }
11764         ndr->depth--;
11765         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11766         ndr->depth++;
11767         if (r->monitor_name) {
11768                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11769         }
11770         ndr->depth--;
11771         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11772         ndr->depth++;
11773         if (r->default_datatype) {
11774                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11775         }
11776         ndr->depth--;
11777         ndr->depth--;
11778 }
11779
11780 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
11781 {
11782         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
11783 }
11784
11785 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
11786 {
11787         if (ndr_flags & NDR_SCALARS) {
11788                 NDR_CHECK(ndr_push_align(ndr, 5));
11789                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11790                 {
11791                         uint32_t _flags_save_string = ndr->flags;
11792                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11793                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11794                         ndr->flags = _flags_save_string;
11795                 }
11796                 {
11797                         uint32_t _flags_save_string = ndr->flags;
11798                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11799                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11800                         ndr->flags = _flags_save_string;
11801                 }
11802                 {
11803                         uint32_t _flags_save_string = ndr->flags;
11804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11805                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11806                         ndr->flags = _flags_save_string;
11807                 }
11808                 {
11809                         uint32_t _flags_save_string = ndr->flags;
11810                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11811                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11812                         ndr->flags = _flags_save_string;
11813                 }
11814                 {
11815                         uint32_t _flags_save_string = ndr->flags;
11816                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11817                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11818                         ndr->flags = _flags_save_string;
11819                 }
11820                 {
11821                         uint32_t _flags_save_string = ndr->flags;
11822                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11823                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11824                         ndr->flags = _flags_save_string;
11825                 }
11826                 {
11827                         uint32_t _flags_save_string_array = ndr->flags;
11828                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11829                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11830                         ndr->flags = _flags_save_string_array;
11831                 }
11832                 {
11833                         uint32_t _flags_save_string = ndr->flags;
11834                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11835                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11836                         ndr->flags = _flags_save_string;
11837                 }
11838                 {
11839                         uint32_t _flags_save_string = ndr->flags;
11840                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11841                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11842                         ndr->flags = _flags_save_string;
11843                 }
11844                 {
11845                         uint32_t _flags_save_string_array = ndr->flags;
11846                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11847                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11848                         ndr->flags = _flags_save_string_array;
11849                 }
11850                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11851         }
11852         if (ndr_flags & NDR_BUFFERS) {
11853                 {
11854                         uint32_t _flags_save_string = ndr->flags;
11855                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11856                         if (r->driver_name) {
11857                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
11858                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11859                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
11860                         }
11861                         ndr->flags = _flags_save_string;
11862                 }
11863                 {
11864                         uint32_t _flags_save_string = ndr->flags;
11865                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11866                         if (r->architecture) {
11867                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
11868                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11869                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
11870                         }
11871                         ndr->flags = _flags_save_string;
11872                 }
11873                 {
11874                         uint32_t _flags_save_string = ndr->flags;
11875                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11876                         if (r->driver_path) {
11877                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
11878                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11879                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
11880                         }
11881                         ndr->flags = _flags_save_string;
11882                 }
11883                 {
11884                         uint32_t _flags_save_string = ndr->flags;
11885                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11886                         if (r->data_file) {
11887                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
11888                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11889                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
11890                         }
11891                         ndr->flags = _flags_save_string;
11892                 }
11893                 {
11894                         uint32_t _flags_save_string = ndr->flags;
11895                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11896                         if (r->config_file) {
11897                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
11898                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11899                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
11900                         }
11901                         ndr->flags = _flags_save_string;
11902                 }
11903                 {
11904                         uint32_t _flags_save_string = ndr->flags;
11905                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11906                         if (r->help_file) {
11907                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
11908                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11909                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
11910                         }
11911                         ndr->flags = _flags_save_string;
11912                 }
11913                 {
11914                         uint32_t _flags_save_string_array = ndr->flags;
11915                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11916                         if (r->dependent_files) {
11917                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
11918                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11919                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
11920                         }
11921                         ndr->flags = _flags_save_string_array;
11922                 }
11923                 {
11924                         uint32_t _flags_save_string = ndr->flags;
11925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11926                         if (r->monitor_name) {
11927                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
11928                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11929                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
11930                         }
11931                         ndr->flags = _flags_save_string;
11932                 }
11933                 {
11934                         uint32_t _flags_save_string = ndr->flags;
11935                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11936                         if (r->default_datatype) {
11937                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
11938                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11939                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
11940                         }
11941                         ndr->flags = _flags_save_string;
11942                 }
11943                 {
11944                         uint32_t _flags_save_string_array = ndr->flags;
11945                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11946                         if (r->previous_names) {
11947                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
11948                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11949                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
11950                         }
11951                         ndr->flags = _flags_save_string_array;
11952                 }
11953         }
11954         return NDR_ERR_SUCCESS;
11955 }
11956
11957 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
11958 {
11959         uint32_t _ptr_driver_name;
11960         TALLOC_CTX *_mem_save_driver_name_0;
11961         uint32_t _ptr_architecture;
11962         TALLOC_CTX *_mem_save_architecture_0;
11963         uint32_t _ptr_driver_path;
11964         TALLOC_CTX *_mem_save_driver_path_0;
11965         uint32_t _ptr_data_file;
11966         TALLOC_CTX *_mem_save_data_file_0;
11967         uint32_t _ptr_config_file;
11968         TALLOC_CTX *_mem_save_config_file_0;
11969         uint32_t _ptr_help_file;
11970         TALLOC_CTX *_mem_save_help_file_0;
11971         uint32_t _ptr_dependent_files;
11972         TALLOC_CTX *_mem_save_dependent_files_0;
11973         uint32_t _ptr_monitor_name;
11974         TALLOC_CTX *_mem_save_monitor_name_0;
11975         uint32_t _ptr_default_datatype;
11976         TALLOC_CTX *_mem_save_default_datatype_0;
11977         uint32_t _ptr_previous_names;
11978         TALLOC_CTX *_mem_save_previous_names_0;
11979         if (ndr_flags & NDR_SCALARS) {
11980                 NDR_CHECK(ndr_pull_align(ndr, 5));
11981                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11982                 {
11983                         uint32_t _flags_save_string = ndr->flags;
11984                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11985                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11986                         if (_ptr_driver_name) {
11987                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11988                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11989                         } else {
11990                                 r->driver_name = NULL;
11991                         }
11992                         ndr->flags = _flags_save_string;
11993                 }
11994                 {
11995                         uint32_t _flags_save_string = ndr->flags;
11996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11997                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11998                         if (_ptr_architecture) {
11999                                 NDR_PULL_ALLOC(ndr, r->architecture);
12000                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12001                         } else {
12002                                 r->architecture = NULL;
12003                         }
12004                         ndr->flags = _flags_save_string;
12005                 }
12006                 {
12007                         uint32_t _flags_save_string = ndr->flags;
12008                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12009                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12010                         if (_ptr_driver_path) {
12011                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12012                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12013                         } else {
12014                                 r->driver_path = NULL;
12015                         }
12016                         ndr->flags = _flags_save_string;
12017                 }
12018                 {
12019                         uint32_t _flags_save_string = ndr->flags;
12020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12021                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12022                         if (_ptr_data_file) {
12023                                 NDR_PULL_ALLOC(ndr, r->data_file);
12024                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12025                         } else {
12026                                 r->data_file = NULL;
12027                         }
12028                         ndr->flags = _flags_save_string;
12029                 }
12030                 {
12031                         uint32_t _flags_save_string = ndr->flags;
12032                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12033                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12034                         if (_ptr_config_file) {
12035                                 NDR_PULL_ALLOC(ndr, r->config_file);
12036                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12037                         } else {
12038                                 r->config_file = NULL;
12039                         }
12040                         ndr->flags = _flags_save_string;
12041                 }
12042                 {
12043                         uint32_t _flags_save_string = ndr->flags;
12044                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12045                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12046                         if (_ptr_help_file) {
12047                                 NDR_PULL_ALLOC(ndr, r->help_file);
12048                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12049                         } else {
12050                                 r->help_file = NULL;
12051                         }
12052                         ndr->flags = _flags_save_string;
12053                 }
12054                 {
12055                         uint32_t _flags_save_string_array = ndr->flags;
12056                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12057                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12058                         if (_ptr_dependent_files) {
12059                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12060                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12061                         } else {
12062                                 r->dependent_files = NULL;
12063                         }
12064                         ndr->flags = _flags_save_string_array;
12065                 }
12066                 {
12067                         uint32_t _flags_save_string = ndr->flags;
12068                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12069                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12070                         if (_ptr_monitor_name) {
12071                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12072                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12073                         } else {
12074                                 r->monitor_name = NULL;
12075                         }
12076                         ndr->flags = _flags_save_string;
12077                 }
12078                 {
12079                         uint32_t _flags_save_string = ndr->flags;
12080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12081                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12082                         if (_ptr_default_datatype) {
12083                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12084                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12085                         } else {
12086                                 r->default_datatype = NULL;
12087                         }
12088                         ndr->flags = _flags_save_string;
12089                 }
12090                 {
12091                         uint32_t _flags_save_string_array = ndr->flags;
12092                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12093                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12094                         if (_ptr_previous_names) {
12095                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12096                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12097                         } else {
12098                                 r->previous_names = NULL;
12099                         }
12100                         ndr->flags = _flags_save_string_array;
12101                 }
12102                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12103         }
12104         if (ndr_flags & NDR_BUFFERS) {
12105                 {
12106                         uint32_t _flags_save_string = ndr->flags;
12107                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12108                         if (r->driver_name) {
12109                                 uint32_t _relative_save_offset;
12110                                 _relative_save_offset = ndr->offset;
12111                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12112                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12113                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12114                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12115                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12116                                 if (ndr->offset > ndr->relative_highest_offset) {
12117                                         ndr->relative_highest_offset = ndr->offset;
12118                                 }
12119                                 ndr->offset = _relative_save_offset;
12120                         }
12121                         ndr->flags = _flags_save_string;
12122                 }
12123                 {
12124                         uint32_t _flags_save_string = ndr->flags;
12125                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12126                         if (r->architecture) {
12127                                 uint32_t _relative_save_offset;
12128                                 _relative_save_offset = ndr->offset;
12129                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12130                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12131                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12132                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12133                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12134                                 if (ndr->offset > ndr->relative_highest_offset) {
12135                                         ndr->relative_highest_offset = ndr->offset;
12136                                 }
12137                                 ndr->offset = _relative_save_offset;
12138                         }
12139                         ndr->flags = _flags_save_string;
12140                 }
12141                 {
12142                         uint32_t _flags_save_string = ndr->flags;
12143                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12144                         if (r->driver_path) {
12145                                 uint32_t _relative_save_offset;
12146                                 _relative_save_offset = ndr->offset;
12147                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12148                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12149                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12150                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12151                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12152                                 if (ndr->offset > ndr->relative_highest_offset) {
12153                                         ndr->relative_highest_offset = ndr->offset;
12154                                 }
12155                                 ndr->offset = _relative_save_offset;
12156                         }
12157                         ndr->flags = _flags_save_string;
12158                 }
12159                 {
12160                         uint32_t _flags_save_string = ndr->flags;
12161                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12162                         if (r->data_file) {
12163                                 uint32_t _relative_save_offset;
12164                                 _relative_save_offset = ndr->offset;
12165                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12166                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12167                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12168                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12169                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12170                                 if (ndr->offset > ndr->relative_highest_offset) {
12171                                         ndr->relative_highest_offset = ndr->offset;
12172                                 }
12173                                 ndr->offset = _relative_save_offset;
12174                         }
12175                         ndr->flags = _flags_save_string;
12176                 }
12177                 {
12178                         uint32_t _flags_save_string = ndr->flags;
12179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12180                         if (r->config_file) {
12181                                 uint32_t _relative_save_offset;
12182                                 _relative_save_offset = ndr->offset;
12183                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12184                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12185                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12186                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12187                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12188                                 if (ndr->offset > ndr->relative_highest_offset) {
12189                                         ndr->relative_highest_offset = ndr->offset;
12190                                 }
12191                                 ndr->offset = _relative_save_offset;
12192                         }
12193                         ndr->flags = _flags_save_string;
12194                 }
12195                 {
12196                         uint32_t _flags_save_string = ndr->flags;
12197                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12198                         if (r->help_file) {
12199                                 uint32_t _relative_save_offset;
12200                                 _relative_save_offset = ndr->offset;
12201                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12202                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12203                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12204                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12205                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12206                                 if (ndr->offset > ndr->relative_highest_offset) {
12207                                         ndr->relative_highest_offset = ndr->offset;
12208                                 }
12209                                 ndr->offset = _relative_save_offset;
12210                         }
12211                         ndr->flags = _flags_save_string;
12212                 }
12213                 {
12214                         uint32_t _flags_save_string_array = ndr->flags;
12215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12216                         if (r->dependent_files) {
12217                                 uint32_t _relative_save_offset;
12218                                 _relative_save_offset = ndr->offset;
12219                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12220                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12221                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12222                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12223                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12224                                 if (ndr->offset > ndr->relative_highest_offset) {
12225                                         ndr->relative_highest_offset = ndr->offset;
12226                                 }
12227                                 ndr->offset = _relative_save_offset;
12228                         }
12229                         ndr->flags = _flags_save_string_array;
12230                 }
12231                 {
12232                         uint32_t _flags_save_string = ndr->flags;
12233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12234                         if (r->monitor_name) {
12235                                 uint32_t _relative_save_offset;
12236                                 _relative_save_offset = ndr->offset;
12237                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12238                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12239                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12240                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12241                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12242                                 if (ndr->offset > ndr->relative_highest_offset) {
12243                                         ndr->relative_highest_offset = ndr->offset;
12244                                 }
12245                                 ndr->offset = _relative_save_offset;
12246                         }
12247                         ndr->flags = _flags_save_string;
12248                 }
12249                 {
12250                         uint32_t _flags_save_string = ndr->flags;
12251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12252                         if (r->default_datatype) {
12253                                 uint32_t _relative_save_offset;
12254                                 _relative_save_offset = ndr->offset;
12255                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12256                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12257                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12258                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12259                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12260                                 if (ndr->offset > ndr->relative_highest_offset) {
12261                                         ndr->relative_highest_offset = ndr->offset;
12262                                 }
12263                                 ndr->offset = _relative_save_offset;
12264                         }
12265                         ndr->flags = _flags_save_string;
12266                 }
12267                 {
12268                         uint32_t _flags_save_string_array = ndr->flags;
12269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12270                         if (r->previous_names) {
12271                                 uint32_t _relative_save_offset;
12272                                 _relative_save_offset = ndr->offset;
12273                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12274                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12275                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12276                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12277                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12278                                 if (ndr->offset > ndr->relative_highest_offset) {
12279                                         ndr->relative_highest_offset = ndr->offset;
12280                                 }
12281                                 ndr->offset = _relative_save_offset;
12282                         }
12283                         ndr->flags = _flags_save_string_array;
12284                 }
12285         }
12286         return NDR_ERR_SUCCESS;
12287 }
12288
12289 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
12290 {
12291         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
12292         ndr->depth++;
12293         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12294         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12295         ndr->depth++;
12296         if (r->driver_name) {
12297                 ndr_print_string(ndr, "driver_name", r->driver_name);
12298         }
12299         ndr->depth--;
12300         ndr_print_ptr(ndr, "architecture", r->architecture);
12301         ndr->depth++;
12302         if (r->architecture) {
12303                 ndr_print_string(ndr, "architecture", r->architecture);
12304         }
12305         ndr->depth--;
12306         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12307         ndr->depth++;
12308         if (r->driver_path) {
12309                 ndr_print_string(ndr, "driver_path", r->driver_path);
12310         }
12311         ndr->depth--;
12312         ndr_print_ptr(ndr, "data_file", r->data_file);
12313         ndr->depth++;
12314         if (r->data_file) {
12315                 ndr_print_string(ndr, "data_file", r->data_file);
12316         }
12317         ndr->depth--;
12318         ndr_print_ptr(ndr, "config_file", r->config_file);
12319         ndr->depth++;
12320         if (r->config_file) {
12321                 ndr_print_string(ndr, "config_file", r->config_file);
12322         }
12323         ndr->depth--;
12324         ndr_print_ptr(ndr, "help_file", r->help_file);
12325         ndr->depth++;
12326         if (r->help_file) {
12327                 ndr_print_string(ndr, "help_file", r->help_file);
12328         }
12329         ndr->depth--;
12330         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12331         ndr->depth++;
12332         if (r->dependent_files) {
12333                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12334         }
12335         ndr->depth--;
12336         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12337         ndr->depth++;
12338         if (r->monitor_name) {
12339                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12340         }
12341         ndr->depth--;
12342         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12343         ndr->depth++;
12344         if (r->default_datatype) {
12345                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12346         }
12347         ndr->depth--;
12348         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12349         ndr->depth++;
12350         if (r->previous_names) {
12351                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12352         }
12353         ndr->depth--;
12354         ndr->depth--;
12355 }
12356
12357 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
12358 {
12359         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
12360 }
12361
12362 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
12363 {
12364         if (ndr_flags & NDR_SCALARS) {
12365                 NDR_CHECK(ndr_push_align(ndr, 5));
12366                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12367                 {
12368                         uint32_t _flags_save_string = ndr->flags;
12369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12370                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12371                         ndr->flags = _flags_save_string;
12372                 }
12373                 {
12374                         uint32_t _flags_save_string = ndr->flags;
12375                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12376                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12377                         ndr->flags = _flags_save_string;
12378                 }
12379                 {
12380                         uint32_t _flags_save_string = ndr->flags;
12381                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12382                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12383                         ndr->flags = _flags_save_string;
12384                 }
12385                 {
12386                         uint32_t _flags_save_string = ndr->flags;
12387                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12388                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12389                         ndr->flags = _flags_save_string;
12390                 }
12391                 {
12392                         uint32_t _flags_save_string = ndr->flags;
12393                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12394                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12395                         ndr->flags = _flags_save_string;
12396                 }
12397                 NDR_CHECK(ndr_push_spoolss_DriverAttributes(ndr, NDR_SCALARS, r->driver_attributes));
12398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
12399                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
12400                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12401         }
12402         if (ndr_flags & NDR_BUFFERS) {
12403                 {
12404                         uint32_t _flags_save_string = ndr->flags;
12405                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12406                         if (r->driver_name) {
12407                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
12408                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12409                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
12410                         }
12411                         ndr->flags = _flags_save_string;
12412                 }
12413                 {
12414                         uint32_t _flags_save_string = ndr->flags;
12415                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12416                         if (r->architecture) {
12417                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
12418                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12419                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
12420                         }
12421                         ndr->flags = _flags_save_string;
12422                 }
12423                 {
12424                         uint32_t _flags_save_string = ndr->flags;
12425                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12426                         if (r->driver_path) {
12427                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
12428                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12429                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
12430                         }
12431                         ndr->flags = _flags_save_string;
12432                 }
12433                 {
12434                         uint32_t _flags_save_string = ndr->flags;
12435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12436                         if (r->data_file) {
12437                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
12438                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12439                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
12440                         }
12441                         ndr->flags = _flags_save_string;
12442                 }
12443                 {
12444                         uint32_t _flags_save_string = ndr->flags;
12445                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12446                         if (r->config_file) {
12447                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
12448                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12449                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
12450                         }
12451                         ndr->flags = _flags_save_string;
12452                 }
12453         }
12454         return NDR_ERR_SUCCESS;
12455 }
12456
12457 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
12458 {
12459         uint32_t _ptr_driver_name;
12460         TALLOC_CTX *_mem_save_driver_name_0;
12461         uint32_t _ptr_architecture;
12462         TALLOC_CTX *_mem_save_architecture_0;
12463         uint32_t _ptr_driver_path;
12464         TALLOC_CTX *_mem_save_driver_path_0;
12465         uint32_t _ptr_data_file;
12466         TALLOC_CTX *_mem_save_data_file_0;
12467         uint32_t _ptr_config_file;
12468         TALLOC_CTX *_mem_save_config_file_0;
12469         if (ndr_flags & NDR_SCALARS) {
12470                 NDR_CHECK(ndr_pull_align(ndr, 5));
12471                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12472                 {
12473                         uint32_t _flags_save_string = ndr->flags;
12474                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12475                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12476                         if (_ptr_driver_name) {
12477                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12478                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12479                         } else {
12480                                 r->driver_name = NULL;
12481                         }
12482                         ndr->flags = _flags_save_string;
12483                 }
12484                 {
12485                         uint32_t _flags_save_string = ndr->flags;
12486                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12487                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12488                         if (_ptr_architecture) {
12489                                 NDR_PULL_ALLOC(ndr, r->architecture);
12490                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12491                         } else {
12492                                 r->architecture = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12500                         if (_ptr_driver_path) {
12501                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12502                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12503                         } else {
12504                                 r->driver_path = NULL;
12505                         }
12506                         ndr->flags = _flags_save_string;
12507                 }
12508                 {
12509                         uint32_t _flags_save_string = ndr->flags;
12510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12511                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12512                         if (_ptr_data_file) {
12513                                 NDR_PULL_ALLOC(ndr, r->data_file);
12514                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12515                         } else {
12516                                 r->data_file = NULL;
12517                         }
12518                         ndr->flags = _flags_save_string;
12519                 }
12520                 {
12521                         uint32_t _flags_save_string = ndr->flags;
12522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12523                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12524                         if (_ptr_config_file) {
12525                                 NDR_PULL_ALLOC(ndr, r->config_file);
12526                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12527                         } else {
12528                                 r->config_file = NULL;
12529                         }
12530                         ndr->flags = _flags_save_string;
12531                 }
12532                 NDR_CHECK(ndr_pull_spoolss_DriverAttributes(ndr, NDR_SCALARS, &r->driver_attributes));
12533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
12534                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
12535                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12536         }
12537         if (ndr_flags & NDR_BUFFERS) {
12538                 {
12539                         uint32_t _flags_save_string = ndr->flags;
12540                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12541                         if (r->driver_name) {
12542                                 uint32_t _relative_save_offset;
12543                                 _relative_save_offset = ndr->offset;
12544                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12545                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12546                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12547                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12548                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12549                                 if (ndr->offset > ndr->relative_highest_offset) {
12550                                         ndr->relative_highest_offset = ndr->offset;
12551                                 }
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->architecture) {
12560                                 uint32_t _relative_save_offset;
12561                                 _relative_save_offset = ndr->offset;
12562                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12563                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12564                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12565                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12566                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12567                                 if (ndr->offset > ndr->relative_highest_offset) {
12568                                         ndr->relative_highest_offset = ndr->offset;
12569                                 }
12570                                 ndr->offset = _relative_save_offset;
12571                         }
12572                         ndr->flags = _flags_save_string;
12573                 }
12574                 {
12575                         uint32_t _flags_save_string = ndr->flags;
12576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12577                         if (r->driver_path) {
12578                                 uint32_t _relative_save_offset;
12579                                 _relative_save_offset = ndr->offset;
12580                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12581                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12582                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12583                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12584                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12585                                 if (ndr->offset > ndr->relative_highest_offset) {
12586                                         ndr->relative_highest_offset = ndr->offset;
12587                                 }
12588                                 ndr->offset = _relative_save_offset;
12589                         }
12590                         ndr->flags = _flags_save_string;
12591                 }
12592                 {
12593                         uint32_t _flags_save_string = ndr->flags;
12594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12595                         if (r->data_file) {
12596                                 uint32_t _relative_save_offset;
12597                                 _relative_save_offset = ndr->offset;
12598                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12599                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12600                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12601                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12602                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12603                                 if (ndr->offset > ndr->relative_highest_offset) {
12604                                         ndr->relative_highest_offset = ndr->offset;
12605                                 }
12606                                 ndr->offset = _relative_save_offset;
12607                         }
12608                         ndr->flags = _flags_save_string;
12609                 }
12610                 {
12611                         uint32_t _flags_save_string = ndr->flags;
12612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12613                         if (r->config_file) {
12614                                 uint32_t _relative_save_offset;
12615                                 _relative_save_offset = ndr->offset;
12616                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12617                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12618                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12619                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12620                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12621                                 if (ndr->offset > ndr->relative_highest_offset) {
12622                                         ndr->relative_highest_offset = ndr->offset;
12623                                 }
12624                                 ndr->offset = _relative_save_offset;
12625                         }
12626                         ndr->flags = _flags_save_string;
12627                 }
12628         }
12629         return NDR_ERR_SUCCESS;
12630 }
12631
12632 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
12633 {
12634         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
12635         ndr->depth++;
12636         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12637         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12638         ndr->depth++;
12639         if (r->driver_name) {
12640                 ndr_print_string(ndr, "driver_name", r->driver_name);
12641         }
12642         ndr->depth--;
12643         ndr_print_ptr(ndr, "architecture", r->architecture);
12644         ndr->depth++;
12645         if (r->architecture) {
12646                 ndr_print_string(ndr, "architecture", r->architecture);
12647         }
12648         ndr->depth--;
12649         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12650         ndr->depth++;
12651         if (r->driver_path) {
12652                 ndr_print_string(ndr, "driver_path", r->driver_path);
12653         }
12654         ndr->depth--;
12655         ndr_print_ptr(ndr, "data_file", r->data_file);
12656         ndr->depth++;
12657         if (r->data_file) {
12658                 ndr_print_string(ndr, "data_file", r->data_file);
12659         }
12660         ndr->depth--;
12661         ndr_print_ptr(ndr, "config_file", r->config_file);
12662         ndr->depth++;
12663         if (r->config_file) {
12664                 ndr_print_string(ndr, "config_file", r->config_file);
12665         }
12666         ndr->depth--;
12667         ndr_print_spoolss_DriverAttributes(ndr, "driver_attributes", r->driver_attributes);
12668         ndr_print_uint32(ndr, "config_version", r->config_version);
12669         ndr_print_uint32(ndr, "driver_version", r->driver_version);
12670         ndr->depth--;
12671 }
12672
12673 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
12674 {
12675         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
12676 }
12677
12678 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
12679 {
12680         if (ndr_flags & NDR_SCALARS) {
12681                 NDR_CHECK(ndr_push_align(ndr, 8));
12682                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12683                 {
12684                         uint32_t _flags_save_string = ndr->flags;
12685                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12686                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12687                         ndr->flags = _flags_save_string;
12688                 }
12689                 {
12690                         uint32_t _flags_save_string = ndr->flags;
12691                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12692                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12693                         ndr->flags = _flags_save_string;
12694                 }
12695                 {
12696                         uint32_t _flags_save_string = ndr->flags;
12697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12698                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12699                         ndr->flags = _flags_save_string;
12700                 }
12701                 {
12702                         uint32_t _flags_save_string = ndr->flags;
12703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12704                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12705                         ndr->flags = _flags_save_string;
12706                 }
12707                 {
12708                         uint32_t _flags_save_string = ndr->flags;
12709                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12710                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12711                         ndr->flags = _flags_save_string;
12712                 }
12713                 {
12714                         uint32_t _flags_save_string = ndr->flags;
12715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12716                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12717                         ndr->flags = _flags_save_string;
12718                 }
12719                 {
12720                         uint32_t _flags_save_string_array = ndr->flags;
12721                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12722                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12723                         ndr->flags = _flags_save_string_array;
12724                 }
12725                 {
12726                         uint32_t _flags_save_string = ndr->flags;
12727                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12728                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12729                         ndr->flags = _flags_save_string;
12730                 }
12731                 {
12732                         uint32_t _flags_save_string = ndr->flags;
12733                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12734                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12735                         ndr->flags = _flags_save_string;
12736                 }
12737                 {
12738                         uint32_t _flags_save_string_array = ndr->flags;
12739                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12740                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12741                         ndr->flags = _flags_save_string_array;
12742                 }
12743                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12744                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12745                 {
12746                         uint32_t _flags_save_string = ndr->flags;
12747                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12748                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12749                         ndr->flags = _flags_save_string;
12750                 }
12751                 {
12752                         uint32_t _flags_save_string = ndr->flags;
12753                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12754                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12755                         ndr->flags = _flags_save_string;
12756                 }
12757                 {
12758                         uint32_t _flags_save_string = ndr->flags;
12759                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12760                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12761                         ndr->flags = _flags_save_string;
12762                 }
12763                 {
12764                         uint32_t _flags_save_string = ndr->flags;
12765                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12766                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12767                         ndr->flags = _flags_save_string;
12768                 }
12769                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12770         }
12771         if (ndr_flags & NDR_BUFFERS) {
12772                 {
12773                         uint32_t _flags_save_string = ndr->flags;
12774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12775                         if (r->driver_name) {
12776                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
12777                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12778                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
12779                         }
12780                         ndr->flags = _flags_save_string;
12781                 }
12782                 {
12783                         uint32_t _flags_save_string = ndr->flags;
12784                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12785                         if (r->architecture) {
12786                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
12787                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12788                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
12789                         }
12790                         ndr->flags = _flags_save_string;
12791                 }
12792                 {
12793                         uint32_t _flags_save_string = ndr->flags;
12794                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12795                         if (r->driver_path) {
12796                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
12797                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12798                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
12799                         }
12800                         ndr->flags = _flags_save_string;
12801                 }
12802                 {
12803                         uint32_t _flags_save_string = ndr->flags;
12804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12805                         if (r->data_file) {
12806                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
12807                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12808                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
12809                         }
12810                         ndr->flags = _flags_save_string;
12811                 }
12812                 {
12813                         uint32_t _flags_save_string = ndr->flags;
12814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12815                         if (r->config_file) {
12816                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
12817                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12818                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
12819                         }
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                         if (r->help_file) {
12826                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
12827                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12828                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
12829                         }
12830                         ndr->flags = _flags_save_string;
12831                 }
12832                 {
12833                         uint32_t _flags_save_string_array = ndr->flags;
12834                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12835                         if (r->dependent_files) {
12836                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
12837                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12838                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
12839                         }
12840                         ndr->flags = _flags_save_string_array;
12841                 }
12842                 {
12843                         uint32_t _flags_save_string = ndr->flags;
12844                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12845                         if (r->monitor_name) {
12846                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
12847                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12848                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
12849                         }
12850                         ndr->flags = _flags_save_string;
12851                 }
12852                 {
12853                         uint32_t _flags_save_string = ndr->flags;
12854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12855                         if (r->default_datatype) {
12856                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
12857                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12858                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
12859                         }
12860                         ndr->flags = _flags_save_string;
12861                 }
12862                 {
12863                         uint32_t _flags_save_string_array = ndr->flags;
12864                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12865                         if (r->previous_names) {
12866                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
12867                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12868                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
12869                         }
12870                         ndr->flags = _flags_save_string_array;
12871                 }
12872                 {
12873                         uint32_t _flags_save_string = ndr->flags;
12874                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12875                         if (r->manufacturer_name) {
12876                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_name));
12877                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12878                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_name));
12879                         }
12880                         ndr->flags = _flags_save_string;
12881                 }
12882                 {
12883                         uint32_t _flags_save_string = ndr->flags;
12884                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12885                         if (r->manufacturer_url) {
12886                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_url));
12887                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12888                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_url));
12889                         }
12890                         ndr->flags = _flags_save_string;
12891                 }
12892                 {
12893                         uint32_t _flags_save_string = ndr->flags;
12894                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12895                         if (r->hardware_id) {
12896                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->hardware_id));
12897                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12898                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->hardware_id));
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->provider) {
12906                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->provider));
12907                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12908                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->provider));
12909                         }
12910                         ndr->flags = _flags_save_string;
12911                 }
12912         }
12913         return NDR_ERR_SUCCESS;
12914 }
12915
12916 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
12917 {
12918         uint32_t _ptr_driver_name;
12919         TALLOC_CTX *_mem_save_driver_name_0;
12920         uint32_t _ptr_architecture;
12921         TALLOC_CTX *_mem_save_architecture_0;
12922         uint32_t _ptr_driver_path;
12923         TALLOC_CTX *_mem_save_driver_path_0;
12924         uint32_t _ptr_data_file;
12925         TALLOC_CTX *_mem_save_data_file_0;
12926         uint32_t _ptr_config_file;
12927         TALLOC_CTX *_mem_save_config_file_0;
12928         uint32_t _ptr_help_file;
12929         TALLOC_CTX *_mem_save_help_file_0;
12930         uint32_t _ptr_dependent_files;
12931         TALLOC_CTX *_mem_save_dependent_files_0;
12932         uint32_t _ptr_monitor_name;
12933         TALLOC_CTX *_mem_save_monitor_name_0;
12934         uint32_t _ptr_default_datatype;
12935         TALLOC_CTX *_mem_save_default_datatype_0;
12936         uint32_t _ptr_previous_names;
12937         TALLOC_CTX *_mem_save_previous_names_0;
12938         uint32_t _ptr_manufacturer_name;
12939         TALLOC_CTX *_mem_save_manufacturer_name_0;
12940         uint32_t _ptr_manufacturer_url;
12941         TALLOC_CTX *_mem_save_manufacturer_url_0;
12942         uint32_t _ptr_hardware_id;
12943         TALLOC_CTX *_mem_save_hardware_id_0;
12944         uint32_t _ptr_provider;
12945         TALLOC_CTX *_mem_save_provider_0;
12946         if (ndr_flags & NDR_SCALARS) {
12947                 NDR_CHECK(ndr_pull_align(ndr, 8));
12948                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12949                 {
12950                         uint32_t _flags_save_string = ndr->flags;
12951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12952                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12953                         if (_ptr_driver_name) {
12954                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12955                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12956                         } else {
12957                                 r->driver_name = NULL;
12958                         }
12959                         ndr->flags = _flags_save_string;
12960                 }
12961                 {
12962                         uint32_t _flags_save_string = ndr->flags;
12963                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12964                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12965                         if (_ptr_architecture) {
12966                                 NDR_PULL_ALLOC(ndr, r->architecture);
12967                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12968                         } else {
12969                                 r->architecture = NULL;
12970                         }
12971                         ndr->flags = _flags_save_string;
12972                 }
12973                 {
12974                         uint32_t _flags_save_string = ndr->flags;
12975                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12976                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12977                         if (_ptr_driver_path) {
12978                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12979                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12980                         } else {
12981                                 r->driver_path = NULL;
12982                         }
12983                         ndr->flags = _flags_save_string;
12984                 }
12985                 {
12986                         uint32_t _flags_save_string = ndr->flags;
12987                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12988                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12989                         if (_ptr_data_file) {
12990                                 NDR_PULL_ALLOC(ndr, r->data_file);
12991                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12992                         } else {
12993                                 r->data_file = NULL;
12994                         }
12995                         ndr->flags = _flags_save_string;
12996                 }
12997                 {
12998                         uint32_t _flags_save_string = ndr->flags;
12999                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13000                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
13001                         if (_ptr_config_file) {
13002                                 NDR_PULL_ALLOC(ndr, r->config_file);
13003                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
13004                         } else {
13005                                 r->config_file = NULL;
13006                         }
13007                         ndr->flags = _flags_save_string;
13008                 }
13009                 {
13010                         uint32_t _flags_save_string = ndr->flags;
13011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13012                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
13013                         if (_ptr_help_file) {
13014                                 NDR_PULL_ALLOC(ndr, r->help_file);
13015                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
13016                         } else {
13017                                 r->help_file = NULL;
13018                         }
13019                         ndr->flags = _flags_save_string;
13020                 }
13021                 {
13022                         uint32_t _flags_save_string_array = ndr->flags;
13023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13024                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
13025                         if (_ptr_dependent_files) {
13026                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
13027                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
13028                         } else {
13029                                 r->dependent_files = NULL;
13030                         }
13031                         ndr->flags = _flags_save_string_array;
13032                 }
13033                 {
13034                         uint32_t _flags_save_string = ndr->flags;
13035                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13036                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
13037                         if (_ptr_monitor_name) {
13038                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
13039                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
13040                         } else {
13041                                 r->monitor_name = NULL;
13042                         }
13043                         ndr->flags = _flags_save_string;
13044                 }
13045                 {
13046                         uint32_t _flags_save_string = ndr->flags;
13047                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13048                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
13049                         if (_ptr_default_datatype) {
13050                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
13051                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
13052                         } else {
13053                                 r->default_datatype = NULL;
13054                         }
13055                         ndr->flags = _flags_save_string;
13056                 }
13057                 {
13058                         uint32_t _flags_save_string_array = ndr->flags;
13059                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13060                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
13061                         if (_ptr_previous_names) {
13062                                 NDR_PULL_ALLOC(ndr, r->previous_names);
13063                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
13064                         } else {
13065                                 r->previous_names = NULL;
13066                         }
13067                         ndr->flags = _flags_save_string_array;
13068                 }
13069                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
13070                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
13071                 {
13072                         uint32_t _flags_save_string = ndr->flags;
13073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13074                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
13075                         if (_ptr_manufacturer_name) {
13076                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
13077                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
13078                         } else {
13079                                 r->manufacturer_name = NULL;
13080                         }
13081                         ndr->flags = _flags_save_string;
13082                 }
13083                 {
13084                         uint32_t _flags_save_string = ndr->flags;
13085                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13086                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
13087                         if (_ptr_manufacturer_url) {
13088                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
13089                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
13090                         } else {
13091                                 r->manufacturer_url = NULL;
13092                         }
13093                         ndr->flags = _flags_save_string;
13094                 }
13095                 {
13096                         uint32_t _flags_save_string = ndr->flags;
13097                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13098                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
13099                         if (_ptr_hardware_id) {
13100                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
13101                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
13102                         } else {
13103                                 r->hardware_id = NULL;
13104                         }
13105                         ndr->flags = _flags_save_string;
13106                 }
13107                 {
13108                         uint32_t _flags_save_string = ndr->flags;
13109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13110                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
13111                         if (_ptr_provider) {
13112                                 NDR_PULL_ALLOC(ndr, r->provider);
13113                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
13114                         } else {
13115                                 r->provider = NULL;
13116                         }
13117                         ndr->flags = _flags_save_string;
13118                 }
13119                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
13120         }
13121         if (ndr_flags & NDR_BUFFERS) {
13122                 {
13123                         uint32_t _flags_save_string = ndr->flags;
13124                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13125                         if (r->driver_name) {
13126                                 uint32_t _relative_save_offset;
13127                                 _relative_save_offset = ndr->offset;
13128                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13129                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13130                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13131                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13132                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13133                                 if (ndr->offset > ndr->relative_highest_offset) {
13134                                         ndr->relative_highest_offset = ndr->offset;
13135                                 }
13136                                 ndr->offset = _relative_save_offset;
13137                         }
13138                         ndr->flags = _flags_save_string;
13139                 }
13140                 {
13141                         uint32_t _flags_save_string = ndr->flags;
13142                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13143                         if (r->architecture) {
13144                                 uint32_t _relative_save_offset;
13145                                 _relative_save_offset = ndr->offset;
13146                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
13147                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
13148                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
13149                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
13150                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
13151                                 if (ndr->offset > ndr->relative_highest_offset) {
13152                                         ndr->relative_highest_offset = ndr->offset;
13153                                 }
13154                                 ndr->offset = _relative_save_offset;
13155                         }
13156                         ndr->flags = _flags_save_string;
13157                 }
13158                 {
13159                         uint32_t _flags_save_string = ndr->flags;
13160                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13161                         if (r->driver_path) {
13162                                 uint32_t _relative_save_offset;
13163                                 _relative_save_offset = ndr->offset;
13164                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
13165                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13166                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
13167                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
13168                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
13169                                 if (ndr->offset > ndr->relative_highest_offset) {
13170                                         ndr->relative_highest_offset = ndr->offset;
13171                                 }
13172                                 ndr->offset = _relative_save_offset;
13173                         }
13174                         ndr->flags = _flags_save_string;
13175                 }
13176                 {
13177                         uint32_t _flags_save_string = ndr->flags;
13178                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13179                         if (r->data_file) {
13180                                 uint32_t _relative_save_offset;
13181                                 _relative_save_offset = ndr->offset;
13182                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
13183                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13184                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
13185                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
13186                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
13187                                 if (ndr->offset > ndr->relative_highest_offset) {
13188                                         ndr->relative_highest_offset = ndr->offset;
13189                                 }
13190                                 ndr->offset = _relative_save_offset;
13191                         }
13192                         ndr->flags = _flags_save_string;
13193                 }
13194                 {
13195                         uint32_t _flags_save_string = ndr->flags;
13196                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13197                         if (r->config_file) {
13198                                 uint32_t _relative_save_offset;
13199                                 _relative_save_offset = ndr->offset;
13200                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
13201                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13202                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
13203                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
13204                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
13205                                 if (ndr->offset > ndr->relative_highest_offset) {
13206                                         ndr->relative_highest_offset = ndr->offset;
13207                                 }
13208                                 ndr->offset = _relative_save_offset;
13209                         }
13210                         ndr->flags = _flags_save_string;
13211                 }
13212                 {
13213                         uint32_t _flags_save_string = ndr->flags;
13214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13215                         if (r->help_file) {
13216                                 uint32_t _relative_save_offset;
13217                                 _relative_save_offset = ndr->offset;
13218                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
13219                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13220                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
13221                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
13222                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
13223                                 if (ndr->offset > ndr->relative_highest_offset) {
13224                                         ndr->relative_highest_offset = ndr->offset;
13225                                 }
13226                                 ndr->offset = _relative_save_offset;
13227                         }
13228                         ndr->flags = _flags_save_string;
13229                 }
13230                 {
13231                         uint32_t _flags_save_string_array = ndr->flags;
13232                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13233                         if (r->dependent_files) {
13234                                 uint32_t _relative_save_offset;
13235                                 _relative_save_offset = ndr->offset;
13236                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
13237                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
13238                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
13239                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
13240                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
13241                                 if (ndr->offset > ndr->relative_highest_offset) {
13242                                         ndr->relative_highest_offset = ndr->offset;
13243                                 }
13244                                 ndr->offset = _relative_save_offset;
13245                         }
13246                         ndr->flags = _flags_save_string_array;
13247                 }
13248                 {
13249                         uint32_t _flags_save_string = ndr->flags;
13250                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13251                         if (r->monitor_name) {
13252                                 uint32_t _relative_save_offset;
13253                                 _relative_save_offset = ndr->offset;
13254                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
13255                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13256                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
13257                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
13258                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
13259                                 if (ndr->offset > ndr->relative_highest_offset) {
13260                                         ndr->relative_highest_offset = ndr->offset;
13261                                 }
13262                                 ndr->offset = _relative_save_offset;
13263                         }
13264                         ndr->flags = _flags_save_string;
13265                 }
13266                 {
13267                         uint32_t _flags_save_string = ndr->flags;
13268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13269                         if (r->default_datatype) {
13270                                 uint32_t _relative_save_offset;
13271                                 _relative_save_offset = ndr->offset;
13272                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
13273                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
13274                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
13275                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
13276                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
13277                                 if (ndr->offset > ndr->relative_highest_offset) {
13278                                         ndr->relative_highest_offset = ndr->offset;
13279                                 }
13280                                 ndr->offset = _relative_save_offset;
13281                         }
13282                         ndr->flags = _flags_save_string;
13283                 }
13284                 {
13285                         uint32_t _flags_save_string_array = ndr->flags;
13286                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13287                         if (r->previous_names) {
13288                                 uint32_t _relative_save_offset;
13289                                 _relative_save_offset = ndr->offset;
13290                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
13291                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
13292                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
13293                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
13294                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
13295                                 if (ndr->offset > ndr->relative_highest_offset) {
13296                                         ndr->relative_highest_offset = ndr->offset;
13297                                 }
13298                                 ndr->offset = _relative_save_offset;
13299                         }
13300                         ndr->flags = _flags_save_string_array;
13301                 }
13302                 {
13303                         uint32_t _flags_save_string = ndr->flags;
13304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13305                         if (r->manufacturer_name) {
13306                                 uint32_t _relative_save_offset;
13307                                 _relative_save_offset = ndr->offset;
13308                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
13309                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13310                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
13311                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
13312                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
13313                                 if (ndr->offset > ndr->relative_highest_offset) {
13314                                         ndr->relative_highest_offset = ndr->offset;
13315                                 }
13316                                 ndr->offset = _relative_save_offset;
13317                         }
13318                         ndr->flags = _flags_save_string;
13319                 }
13320                 {
13321                         uint32_t _flags_save_string = ndr->flags;
13322                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13323                         if (r->manufacturer_url) {
13324                                 uint32_t _relative_save_offset;
13325                                 _relative_save_offset = ndr->offset;
13326                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
13327                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
13328                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
13329                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
13330                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13331                                 if (ndr->offset > ndr->relative_highest_offset) {
13332                                         ndr->relative_highest_offset = ndr->offset;
13333                                 }
13334                                 ndr->offset = _relative_save_offset;
13335                         }
13336                         ndr->flags = _flags_save_string;
13337                 }
13338                 {
13339                         uint32_t _flags_save_string = ndr->flags;
13340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13341                         if (r->hardware_id) {
13342                                 uint32_t _relative_save_offset;
13343                                 _relative_save_offset = ndr->offset;
13344                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13345                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13346                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13347                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13348                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13349                                 if (ndr->offset > ndr->relative_highest_offset) {
13350                                         ndr->relative_highest_offset = ndr->offset;
13351                                 }
13352                                 ndr->offset = _relative_save_offset;
13353                         }
13354                         ndr->flags = _flags_save_string;
13355                 }
13356                 {
13357                         uint32_t _flags_save_string = ndr->flags;
13358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13359                         if (r->provider) {
13360                                 uint32_t _relative_save_offset;
13361                                 _relative_save_offset = ndr->offset;
13362                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13363                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13364                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13365                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13366                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13367                                 if (ndr->offset > ndr->relative_highest_offset) {
13368                                         ndr->relative_highest_offset = ndr->offset;
13369                                 }
13370                                 ndr->offset = _relative_save_offset;
13371                         }
13372                         ndr->flags = _flags_save_string;
13373                 }
13374         }
13375         return NDR_ERR_SUCCESS;
13376 }
13377
13378 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
13379 {
13380         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
13381         ndr->depth++;
13382         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13383         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13384         ndr->depth++;
13385         if (r->driver_name) {
13386                 ndr_print_string(ndr, "driver_name", r->driver_name);
13387         }
13388         ndr->depth--;
13389         ndr_print_ptr(ndr, "architecture", r->architecture);
13390         ndr->depth++;
13391         if (r->architecture) {
13392                 ndr_print_string(ndr, "architecture", r->architecture);
13393         }
13394         ndr->depth--;
13395         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13396         ndr->depth++;
13397         if (r->driver_path) {
13398                 ndr_print_string(ndr, "driver_path", r->driver_path);
13399         }
13400         ndr->depth--;
13401         ndr_print_ptr(ndr, "data_file", r->data_file);
13402         ndr->depth++;
13403         if (r->data_file) {
13404                 ndr_print_string(ndr, "data_file", r->data_file);
13405         }
13406         ndr->depth--;
13407         ndr_print_ptr(ndr, "config_file", r->config_file);
13408         ndr->depth++;
13409         if (r->config_file) {
13410                 ndr_print_string(ndr, "config_file", r->config_file);
13411         }
13412         ndr->depth--;
13413         ndr_print_ptr(ndr, "help_file", r->help_file);
13414         ndr->depth++;
13415         if (r->help_file) {
13416                 ndr_print_string(ndr, "help_file", r->help_file);
13417         }
13418         ndr->depth--;
13419         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13420         ndr->depth++;
13421         if (r->dependent_files) {
13422                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13423         }
13424         ndr->depth--;
13425         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13426         ndr->depth++;
13427         if (r->monitor_name) {
13428                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13429         }
13430         ndr->depth--;
13431         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13432         ndr->depth++;
13433         if (r->default_datatype) {
13434                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13435         }
13436         ndr->depth--;
13437         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13438         ndr->depth++;
13439         if (r->previous_names) {
13440                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13441         }
13442         ndr->depth--;
13443         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13444         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13445         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13446         ndr->depth++;
13447         if (r->manufacturer_name) {
13448                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13449         }
13450         ndr->depth--;
13451         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13452         ndr->depth++;
13453         if (r->manufacturer_url) {
13454                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13455         }
13456         ndr->depth--;
13457         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13458         ndr->depth++;
13459         if (r->hardware_id) {
13460                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13461         }
13462         ndr->depth--;
13463         ndr_print_ptr(ndr, "provider", r->provider);
13464         ndr->depth++;
13465         if (r->provider) {
13466                 ndr_print_string(ndr, "provider", r->provider);
13467         }
13468         ndr->depth--;
13469         ndr->depth--;
13470 }
13471
13472 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
13473 {
13474         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
13475 }
13476
13477 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo7 *r)
13478 {
13479         if (ndr_flags & NDR_SCALARS) {
13480                 NDR_CHECK(ndr_push_align(ndr, 5));
13481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13482                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
13483                 {
13484                         uint32_t _flags_save_string = ndr->flags;
13485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13486                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
13487                         ndr->flags = _flags_save_string;
13488                 }
13489                 {
13490                         uint32_t _flags_save_string = ndr->flags;
13491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13492                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_name));
13493                         ndr->flags = _flags_save_string;
13494                 }
13495                 {
13496                         uint32_t _flags_save_string = ndr->flags;
13497                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13498                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->install_source_root));
13499                         ndr->flags = _flags_save_string;
13500                 }
13501                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13502         }
13503         if (ndr_flags & NDR_BUFFERS) {
13504                 {
13505                         uint32_t _flags_save_string = ndr->flags;
13506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13507                         if (r->driver_name) {
13508                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
13509                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
13510                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
13511                         }
13512                         ndr->flags = _flags_save_string;
13513                 }
13514                 {
13515                         uint32_t _flags_save_string = ndr->flags;
13516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13517                         if (r->inf_name) {
13518                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->inf_name));
13519                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_name));
13520                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->inf_name));
13521                         }
13522                         ndr->flags = _flags_save_string;
13523                 }
13524                 {
13525                         uint32_t _flags_save_string = ndr->flags;
13526                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13527                         if (r->install_source_root) {
13528                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->install_source_root));
13529                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->install_source_root));
13530                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->install_source_root));
13531                         }
13532                         ndr->flags = _flags_save_string;
13533                 }
13534         }
13535         return NDR_ERR_SUCCESS;
13536 }
13537
13538 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo7 *r)
13539 {
13540         uint32_t _ptr_driver_name;
13541         TALLOC_CTX *_mem_save_driver_name_0;
13542         uint32_t _ptr_inf_name;
13543         TALLOC_CTX *_mem_save_inf_name_0;
13544         uint32_t _ptr_install_source_root;
13545         TALLOC_CTX *_mem_save_install_source_root_0;
13546         if (ndr_flags & NDR_SCALARS) {
13547                 NDR_CHECK(ndr_pull_align(ndr, 5));
13548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
13549                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13550                 {
13551                         uint32_t _flags_save_string = ndr->flags;
13552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13553                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13554                         if (_ptr_driver_name) {
13555                                 NDR_PULL_ALLOC(ndr, r->driver_name);
13556                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13557                         } else {
13558                                 r->driver_name = NULL;
13559                         }
13560                         ndr->flags = _flags_save_string;
13561                 }
13562                 {
13563                         uint32_t _flags_save_string = ndr->flags;
13564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13565                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_name));
13566                         if (_ptr_inf_name) {
13567                                 NDR_PULL_ALLOC(ndr, r->inf_name);
13568                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_name, _ptr_inf_name));
13569                         } else {
13570                                 r->inf_name = NULL;
13571                         }
13572                         ndr->flags = _flags_save_string;
13573                 }
13574                 {
13575                         uint32_t _flags_save_string = ndr->flags;
13576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13577                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_install_source_root));
13578                         if (_ptr_install_source_root) {
13579                                 NDR_PULL_ALLOC(ndr, r->install_source_root);
13580                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->install_source_root, _ptr_install_source_root));
13581                         } else {
13582                                 r->install_source_root = NULL;
13583                         }
13584                         ndr->flags = _flags_save_string;
13585                 }
13586                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13587         }
13588         if (ndr_flags & NDR_BUFFERS) {
13589                 {
13590                         uint32_t _flags_save_string = ndr->flags;
13591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13592                         if (r->driver_name) {
13593                                 uint32_t _relative_save_offset;
13594                                 _relative_save_offset = ndr->offset;
13595                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13596                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13597                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13598                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13599                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13600                                 if (ndr->offset > ndr->relative_highest_offset) {
13601                                         ndr->relative_highest_offset = ndr->offset;
13602                                 }
13603                                 ndr->offset = _relative_save_offset;
13604                         }
13605                         ndr->flags = _flags_save_string;
13606                 }
13607                 {
13608                         uint32_t _flags_save_string = ndr->flags;
13609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13610                         if (r->inf_name) {
13611                                 uint32_t _relative_save_offset;
13612                                 _relative_save_offset = ndr->offset;
13613                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_name));
13614                                 _mem_save_inf_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13615                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_name, 0);
13616                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_name));
13617                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_name_0, 0);
13618                                 if (ndr->offset > ndr->relative_highest_offset) {
13619                                         ndr->relative_highest_offset = ndr->offset;
13620                                 }
13621                                 ndr->offset = _relative_save_offset;
13622                         }
13623                         ndr->flags = _flags_save_string;
13624                 }
13625                 {
13626                         uint32_t _flags_save_string = ndr->flags;
13627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13628                         if (r->install_source_root) {
13629                                 uint32_t _relative_save_offset;
13630                                 _relative_save_offset = ndr->offset;
13631                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->install_source_root));
13632                                 _mem_save_install_source_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
13633                                 NDR_PULL_SET_MEM_CTX(ndr, r->install_source_root, 0);
13634                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->install_source_root));
13635                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_install_source_root_0, 0);
13636                                 if (ndr->offset > ndr->relative_highest_offset) {
13637                                         ndr->relative_highest_offset = ndr->offset;
13638                                 }
13639                                 ndr->offset = _relative_save_offset;
13640                         }
13641                         ndr->flags = _flags_save_string;
13642                 }
13643         }
13644         return NDR_ERR_SUCCESS;
13645 }
13646
13647 _PUBLIC_ void ndr_print_spoolss_DriverInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo7 *r)
13648 {
13649         ndr_print_struct(ndr, name, "spoolss_DriverInfo7");
13650         ndr->depth++;
13651         ndr_print_uint32(ndr, "size", r->size);
13652         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13653         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13654         ndr->depth++;
13655         if (r->driver_name) {
13656                 ndr_print_string(ndr, "driver_name", r->driver_name);
13657         }
13658         ndr->depth--;
13659         ndr_print_ptr(ndr, "inf_name", r->inf_name);
13660         ndr->depth++;
13661         if (r->inf_name) {
13662                 ndr_print_string(ndr, "inf_name", r->inf_name);
13663         }
13664         ndr->depth--;
13665         ndr_print_ptr(ndr, "install_source_root", r->install_source_root);
13666         ndr->depth++;
13667         if (r->install_source_root) {
13668                 ndr_print_string(ndr, "install_source_root", r->install_source_root);
13669         }
13670         ndr->depth--;
13671         ndr->depth--;
13672 }
13673
13674 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo7(const struct spoolss_DriverInfo7 *r, struct smb_iconv_convenience *ic, int flags)
13675 {
13676         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo7, ic);
13677 }
13678
13679 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
13680 {
13681         if (ndr_flags & NDR_SCALARS) {
13682                 NDR_CHECK(ndr_push_align(ndr, 8));
13683                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
13684                 {
13685                         uint32_t _flags_save_string = ndr->flags;
13686                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13687                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
13688                         ndr->flags = _flags_save_string;
13689                 }
13690                 {
13691                         uint32_t _flags_save_string = ndr->flags;
13692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13693                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
13694                         ndr->flags = _flags_save_string;
13695                 }
13696                 {
13697                         uint32_t _flags_save_string = ndr->flags;
13698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13699                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
13700                         ndr->flags = _flags_save_string;
13701                 }
13702                 {
13703                         uint32_t _flags_save_string = ndr->flags;
13704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13705                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
13706                         ndr->flags = _flags_save_string;
13707                 }
13708                 {
13709                         uint32_t _flags_save_string = ndr->flags;
13710                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13711                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
13712                         ndr->flags = _flags_save_string;
13713                 }
13714                 {
13715                         uint32_t _flags_save_string = ndr->flags;
13716                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13717                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
13718                         ndr->flags = _flags_save_string;
13719                 }
13720                 {
13721                         uint32_t _flags_save_string_array = ndr->flags;
13722                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13723                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
13724                         ndr->flags = _flags_save_string_array;
13725                 }
13726                 {
13727                         uint32_t _flags_save_string = ndr->flags;
13728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13729                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
13730                         ndr->flags = _flags_save_string;
13731                 }
13732                 {
13733                         uint32_t _flags_save_string = ndr->flags;
13734                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13735                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
13736                         ndr->flags = _flags_save_string;
13737                 }
13738                 {
13739                         uint32_t _flags_save_string_array = ndr->flags;
13740                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13741                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
13742                         ndr->flags = _flags_save_string_array;
13743                 }
13744                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
13745                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
13746                 {
13747                         uint32_t _flags_save_string = ndr->flags;
13748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13749                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
13750                         ndr->flags = _flags_save_string;
13751                 }
13752                 {
13753                         uint32_t _flags_save_string = ndr->flags;
13754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13755                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
13756                         ndr->flags = _flags_save_string;
13757                 }
13758                 {
13759                         uint32_t _flags_save_string = ndr->flags;
13760                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13761                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
13762                         ndr->flags = _flags_save_string;
13763                 }
13764                 {
13765                         uint32_t _flags_save_string = ndr->flags;
13766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13767                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
13768                         ndr->flags = _flags_save_string;
13769                 }
13770                 {
13771                         uint32_t _flags_save_string = ndr->flags;
13772                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13773                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
13774                         ndr->flags = _flags_save_string;
13775                 }
13776                 {
13777                         uint32_t _flags_save_string = ndr->flags;
13778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13779                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
13780                         ndr->flags = _flags_save_string;
13781                 }
13782                 {
13783                         uint32_t _flags_save_string_array = ndr->flags;
13784                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13785                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
13786                         ndr->flags = _flags_save_string_array;
13787                 }
13788                 {
13789                         uint32_t _flags_save_string = ndr->flags;
13790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13791                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
13792                         ndr->flags = _flags_save_string;
13793                 }
13794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
13795                 {
13796                         uint32_t _flags_save_string_array = ndr->flags;
13797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13798                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
13799                         ndr->flags = _flags_save_string_array;
13800                 }
13801                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
13802                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
13803                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
13804         }
13805         if (ndr_flags & NDR_BUFFERS) {
13806                 {
13807                         uint32_t _flags_save_string = ndr->flags;
13808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13809                         if (r->driver_name) {
13810                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
13811                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
13812                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
13813                         }
13814                         ndr->flags = _flags_save_string;
13815                 }
13816                 {
13817                         uint32_t _flags_save_string = ndr->flags;
13818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13819                         if (r->architecture) {
13820                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
13821                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
13822                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
13823                         }
13824                         ndr->flags = _flags_save_string;
13825                 }
13826                 {
13827                         uint32_t _flags_save_string = ndr->flags;
13828                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13829                         if (r->driver_path) {
13830                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
13831                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
13832                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
13833                         }
13834                         ndr->flags = _flags_save_string;
13835                 }
13836                 {
13837                         uint32_t _flags_save_string = ndr->flags;
13838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13839                         if (r->data_file) {
13840                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
13841                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
13842                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
13843                         }
13844                         ndr->flags = _flags_save_string;
13845                 }
13846                 {
13847                         uint32_t _flags_save_string = ndr->flags;
13848                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13849                         if (r->config_file) {
13850                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
13851                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
13852                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
13853                         }
13854                         ndr->flags = _flags_save_string;
13855                 }
13856                 {
13857                         uint32_t _flags_save_string = ndr->flags;
13858                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13859                         if (r->help_file) {
13860                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
13861                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
13862                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
13863                         }
13864                         ndr->flags = _flags_save_string;
13865                 }
13866                 {
13867                         uint32_t _flags_save_string_array = ndr->flags;
13868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13869                         if (r->dependent_files) {
13870                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
13871                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
13872                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
13873                         }
13874                         ndr->flags = _flags_save_string_array;
13875                 }
13876                 {
13877                         uint32_t _flags_save_string = ndr->flags;
13878                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13879                         if (r->monitor_name) {
13880                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
13881                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
13882                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
13883                         }
13884                         ndr->flags = _flags_save_string;
13885                 }
13886                 {
13887                         uint32_t _flags_save_string = ndr->flags;
13888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13889                         if (r->default_datatype) {
13890                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
13891                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
13892                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
13893                         }
13894                         ndr->flags = _flags_save_string;
13895                 }
13896                 {
13897                         uint32_t _flags_save_string_array = ndr->flags;
13898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13899                         if (r->previous_names) {
13900                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
13901                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
13902                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
13903                         }
13904                         ndr->flags = _flags_save_string_array;
13905                 }
13906                 {
13907                         uint32_t _flags_save_string = ndr->flags;
13908                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13909                         if (r->manufacturer_name) {
13910                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_name));
13911                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
13912                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_name));
13913                         }
13914                         ndr->flags = _flags_save_string;
13915                 }
13916                 {
13917                         uint32_t _flags_save_string = ndr->flags;
13918                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13919                         if (r->manufacturer_url) {
13920                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_url));
13921                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
13922                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_url));
13923                         }
13924                         ndr->flags = _flags_save_string;
13925                 }
13926                 {
13927                         uint32_t _flags_save_string = ndr->flags;
13928                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13929                         if (r->hardware_id) {
13930                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->hardware_id));
13931                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
13932                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->hardware_id));
13933                         }
13934                         ndr->flags = _flags_save_string;
13935                 }
13936                 {
13937                         uint32_t _flags_save_string = ndr->flags;
13938                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13939                         if (r->provider) {
13940                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->provider));
13941                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
13942                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->provider));
13943                         }
13944                         ndr->flags = _flags_save_string;
13945                 }
13946                 {
13947                         uint32_t _flags_save_string = ndr->flags;
13948                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13949                         if (r->print_processor) {
13950                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
13951                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
13952                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
13953                         }
13954                         ndr->flags = _flags_save_string;
13955                 }
13956                 {
13957                         uint32_t _flags_save_string = ndr->flags;
13958                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13959                         if (r->vendor_setup) {
13960                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->vendor_setup));
13961                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
13962                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->vendor_setup));
13963                         }
13964                         ndr->flags = _flags_save_string;
13965                 }
13966                 {
13967                         uint32_t _flags_save_string_array = ndr->flags;
13968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13969                         if (r->color_profiles) {
13970                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->color_profiles));
13971                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
13972                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->color_profiles));
13973                         }
13974                         ndr->flags = _flags_save_string_array;
13975                 }
13976                 {
13977                         uint32_t _flags_save_string = ndr->flags;
13978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13979                         if (r->inf_path) {
13980                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->inf_path));
13981                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
13982                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->inf_path));
13983                         }
13984                         ndr->flags = _flags_save_string;
13985                 }
13986                 {
13987                         uint32_t _flags_save_string_array = ndr->flags;
13988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13989                         if (r->core_driver_dependencies) {
13990                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->core_driver_dependencies));
13991                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
13992                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->core_driver_dependencies));
13993                         }
13994                         ndr->flags = _flags_save_string_array;
13995                 }
13996         }
13997         return NDR_ERR_SUCCESS;
13998 }
13999
14000 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
14001 {
14002         uint32_t _ptr_driver_name;
14003         TALLOC_CTX *_mem_save_driver_name_0;
14004         uint32_t _ptr_architecture;
14005         TALLOC_CTX *_mem_save_architecture_0;
14006         uint32_t _ptr_driver_path;
14007         TALLOC_CTX *_mem_save_driver_path_0;
14008         uint32_t _ptr_data_file;
14009         TALLOC_CTX *_mem_save_data_file_0;
14010         uint32_t _ptr_config_file;
14011         TALLOC_CTX *_mem_save_config_file_0;
14012         uint32_t _ptr_help_file;
14013         TALLOC_CTX *_mem_save_help_file_0;
14014         uint32_t _ptr_dependent_files;
14015         TALLOC_CTX *_mem_save_dependent_files_0;
14016         uint32_t _ptr_monitor_name;
14017         TALLOC_CTX *_mem_save_monitor_name_0;
14018         uint32_t _ptr_default_datatype;
14019         TALLOC_CTX *_mem_save_default_datatype_0;
14020         uint32_t _ptr_previous_names;
14021         TALLOC_CTX *_mem_save_previous_names_0;
14022         uint32_t _ptr_manufacturer_name;
14023         TALLOC_CTX *_mem_save_manufacturer_name_0;
14024         uint32_t _ptr_manufacturer_url;
14025         TALLOC_CTX *_mem_save_manufacturer_url_0;
14026         uint32_t _ptr_hardware_id;
14027         TALLOC_CTX *_mem_save_hardware_id_0;
14028         uint32_t _ptr_provider;
14029         TALLOC_CTX *_mem_save_provider_0;
14030         uint32_t _ptr_print_processor;
14031         TALLOC_CTX *_mem_save_print_processor_0;
14032         uint32_t _ptr_vendor_setup;
14033         TALLOC_CTX *_mem_save_vendor_setup_0;
14034         uint32_t _ptr_color_profiles;
14035         TALLOC_CTX *_mem_save_color_profiles_0;
14036         uint32_t _ptr_inf_path;
14037         TALLOC_CTX *_mem_save_inf_path_0;
14038         uint32_t _ptr_core_driver_dependencies;
14039         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
14040         if (ndr_flags & NDR_SCALARS) {
14041                 NDR_CHECK(ndr_pull_align(ndr, 8));
14042                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
14043                 {
14044                         uint32_t _flags_save_string = ndr->flags;
14045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14046                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
14047                         if (_ptr_driver_name) {
14048                                 NDR_PULL_ALLOC(ndr, r->driver_name);
14049                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
14050                         } else {
14051                                 r->driver_name = NULL;
14052                         }
14053                         ndr->flags = _flags_save_string;
14054                 }
14055                 {
14056                         uint32_t _flags_save_string = ndr->flags;
14057                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14058                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
14059                         if (_ptr_architecture) {
14060                                 NDR_PULL_ALLOC(ndr, r->architecture);
14061                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
14062                         } else {
14063                                 r->architecture = NULL;
14064                         }
14065                         ndr->flags = _flags_save_string;
14066                 }
14067                 {
14068                         uint32_t _flags_save_string = ndr->flags;
14069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14070                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
14071                         if (_ptr_driver_path) {
14072                                 NDR_PULL_ALLOC(ndr, r->driver_path);
14073                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
14074                         } else {
14075                                 r->driver_path = NULL;
14076                         }
14077                         ndr->flags = _flags_save_string;
14078                 }
14079                 {
14080                         uint32_t _flags_save_string = ndr->flags;
14081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14082                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
14083                         if (_ptr_data_file) {
14084                                 NDR_PULL_ALLOC(ndr, r->data_file);
14085                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
14086                         } else {
14087                                 r->data_file = NULL;
14088                         }
14089                         ndr->flags = _flags_save_string;
14090                 }
14091                 {
14092                         uint32_t _flags_save_string = ndr->flags;
14093                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14094                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
14095                         if (_ptr_config_file) {
14096                                 NDR_PULL_ALLOC(ndr, r->config_file);
14097                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
14098                         } else {
14099                                 r->config_file = NULL;
14100                         }
14101                         ndr->flags = _flags_save_string;
14102                 }
14103                 {
14104                         uint32_t _flags_save_string = ndr->flags;
14105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14106                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
14107                         if (_ptr_help_file) {
14108                                 NDR_PULL_ALLOC(ndr, r->help_file);
14109                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
14110                         } else {
14111                                 r->help_file = NULL;
14112                         }
14113                         ndr->flags = _flags_save_string;
14114                 }
14115                 {
14116                         uint32_t _flags_save_string_array = ndr->flags;
14117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14118                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
14119                         if (_ptr_dependent_files) {
14120                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
14121                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
14122                         } else {
14123                                 r->dependent_files = NULL;
14124                         }
14125                         ndr->flags = _flags_save_string_array;
14126                 }
14127                 {
14128                         uint32_t _flags_save_string = ndr->flags;
14129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14130                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
14131                         if (_ptr_monitor_name) {
14132                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
14133                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
14134                         } else {
14135                                 r->monitor_name = NULL;
14136                         }
14137                         ndr->flags = _flags_save_string;
14138                 }
14139                 {
14140                         uint32_t _flags_save_string = ndr->flags;
14141                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14142                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
14143                         if (_ptr_default_datatype) {
14144                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
14145                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
14146                         } else {
14147                                 r->default_datatype = NULL;
14148                         }
14149                         ndr->flags = _flags_save_string;
14150                 }
14151                 {
14152                         uint32_t _flags_save_string_array = ndr->flags;
14153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14154                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
14155                         if (_ptr_previous_names) {
14156                                 NDR_PULL_ALLOC(ndr, r->previous_names);
14157                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
14158                         } else {
14159                                 r->previous_names = NULL;
14160                         }
14161                         ndr->flags = _flags_save_string_array;
14162                 }
14163                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
14164                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
14165                 {
14166                         uint32_t _flags_save_string = ndr->flags;
14167                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14168                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
14169                         if (_ptr_manufacturer_name) {
14170                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
14171                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
14172                         } else {
14173                                 r->manufacturer_name = NULL;
14174                         }
14175                         ndr->flags = _flags_save_string;
14176                 }
14177                 {
14178                         uint32_t _flags_save_string = ndr->flags;
14179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14180                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
14181                         if (_ptr_manufacturer_url) {
14182                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
14183                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
14184                         } else {
14185                                 r->manufacturer_url = NULL;
14186                         }
14187                         ndr->flags = _flags_save_string;
14188                 }
14189                 {
14190                         uint32_t _flags_save_string = ndr->flags;
14191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14192                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
14193                         if (_ptr_hardware_id) {
14194                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
14195                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
14196                         } else {
14197                                 r->hardware_id = NULL;
14198                         }
14199                         ndr->flags = _flags_save_string;
14200                 }
14201                 {
14202                         uint32_t _flags_save_string = ndr->flags;
14203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14204                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
14205                         if (_ptr_provider) {
14206                                 NDR_PULL_ALLOC(ndr, r->provider);
14207                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
14208                         } else {
14209                                 r->provider = NULL;
14210                         }
14211                         ndr->flags = _flags_save_string;
14212                 }
14213                 {
14214                         uint32_t _flags_save_string = ndr->flags;
14215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14216                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
14217                         if (_ptr_print_processor) {
14218                                 NDR_PULL_ALLOC(ndr, r->print_processor);
14219                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
14220                         } else {
14221                                 r->print_processor = NULL;
14222                         }
14223                         ndr->flags = _flags_save_string;
14224                 }
14225                 {
14226                         uint32_t _flags_save_string = ndr->flags;
14227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14228                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
14229                         if (_ptr_vendor_setup) {
14230                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
14231                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
14232                         } else {
14233                                 r->vendor_setup = NULL;
14234                         }
14235                         ndr->flags = _flags_save_string;
14236                 }
14237                 {
14238                         uint32_t _flags_save_string_array = ndr->flags;
14239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14240                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
14241                         if (_ptr_color_profiles) {
14242                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
14243                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
14244                         } else {
14245                                 r->color_profiles = NULL;
14246                         }
14247                         ndr->flags = _flags_save_string_array;
14248                 }
14249                 {
14250                         uint32_t _flags_save_string = ndr->flags;
14251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14252                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
14253                         if (_ptr_inf_path) {
14254                                 NDR_PULL_ALLOC(ndr, r->inf_path);
14255                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
14256                         } else {
14257                                 r->inf_path = NULL;
14258                         }
14259                         ndr->flags = _flags_save_string;
14260                 }
14261                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
14262                 {
14263                         uint32_t _flags_save_string_array = ndr->flags;
14264                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14265                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
14266                         if (_ptr_core_driver_dependencies) {
14267                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
14268                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
14269                         } else {
14270                                 r->core_driver_dependencies = NULL;
14271                         }
14272                         ndr->flags = _flags_save_string_array;
14273                 }
14274                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
14275                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
14276                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
14277         }
14278         if (ndr_flags & NDR_BUFFERS) {
14279                 {
14280                         uint32_t _flags_save_string = ndr->flags;
14281                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14282                         if (r->driver_name) {
14283                                 uint32_t _relative_save_offset;
14284                                 _relative_save_offset = ndr->offset;
14285                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
14286                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14287                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
14288                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
14289                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
14290                                 if (ndr->offset > ndr->relative_highest_offset) {
14291                                         ndr->relative_highest_offset = ndr->offset;
14292                                 }
14293                                 ndr->offset = _relative_save_offset;
14294                         }
14295                         ndr->flags = _flags_save_string;
14296                 }
14297                 {
14298                         uint32_t _flags_save_string = ndr->flags;
14299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14300                         if (r->architecture) {
14301                                 uint32_t _relative_save_offset;
14302                                 _relative_save_offset = ndr->offset;
14303                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
14304                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
14305                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
14306                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
14307                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
14308                                 if (ndr->offset > ndr->relative_highest_offset) {
14309                                         ndr->relative_highest_offset = ndr->offset;
14310                                 }
14311                                 ndr->offset = _relative_save_offset;
14312                         }
14313                         ndr->flags = _flags_save_string;
14314                 }
14315                 {
14316                         uint32_t _flags_save_string = ndr->flags;
14317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14318                         if (r->driver_path) {
14319                                 uint32_t _relative_save_offset;
14320                                 _relative_save_offset = ndr->offset;
14321                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
14322                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
14323                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
14324                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
14325                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
14326                                 if (ndr->offset > ndr->relative_highest_offset) {
14327                                         ndr->relative_highest_offset = ndr->offset;
14328                                 }
14329                                 ndr->offset = _relative_save_offset;
14330                         }
14331                         ndr->flags = _flags_save_string;
14332                 }
14333                 {
14334                         uint32_t _flags_save_string = ndr->flags;
14335                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14336                         if (r->data_file) {
14337                                 uint32_t _relative_save_offset;
14338                                 _relative_save_offset = ndr->offset;
14339                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
14340                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14341                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
14342                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
14343                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
14344                                 if (ndr->offset > ndr->relative_highest_offset) {
14345                                         ndr->relative_highest_offset = ndr->offset;
14346                                 }
14347                                 ndr->offset = _relative_save_offset;
14348                         }
14349                         ndr->flags = _flags_save_string;
14350                 }
14351                 {
14352                         uint32_t _flags_save_string = ndr->flags;
14353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14354                         if (r->config_file) {
14355                                 uint32_t _relative_save_offset;
14356                                 _relative_save_offset = ndr->offset;
14357                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
14358                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14359                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
14360                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
14361                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
14362                                 if (ndr->offset > ndr->relative_highest_offset) {
14363                                         ndr->relative_highest_offset = ndr->offset;
14364                                 }
14365                                 ndr->offset = _relative_save_offset;
14366                         }
14367                         ndr->flags = _flags_save_string;
14368                 }
14369                 {
14370                         uint32_t _flags_save_string = ndr->flags;
14371                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14372                         if (r->help_file) {
14373                                 uint32_t _relative_save_offset;
14374                                 _relative_save_offset = ndr->offset;
14375                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
14376                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14377                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
14378                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
14379                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
14380                                 if (ndr->offset > ndr->relative_highest_offset) {
14381                                         ndr->relative_highest_offset = ndr->offset;
14382                                 }
14383                                 ndr->offset = _relative_save_offset;
14384                         }
14385                         ndr->flags = _flags_save_string;
14386                 }
14387                 {
14388                         uint32_t _flags_save_string_array = ndr->flags;
14389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14390                         if (r->dependent_files) {
14391                                 uint32_t _relative_save_offset;
14392                                 _relative_save_offset = ndr->offset;
14393                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
14394                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
14395                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
14396                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
14397                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
14398                                 if (ndr->offset > ndr->relative_highest_offset) {
14399                                         ndr->relative_highest_offset = ndr->offset;
14400                                 }
14401                                 ndr->offset = _relative_save_offset;
14402                         }
14403                         ndr->flags = _flags_save_string_array;
14404                 }
14405                 {
14406                         uint32_t _flags_save_string = ndr->flags;
14407                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14408                         if (r->monitor_name) {
14409                                 uint32_t _relative_save_offset;
14410                                 _relative_save_offset = ndr->offset;
14411                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
14412                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14413                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
14414                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
14415                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
14416                                 if (ndr->offset > ndr->relative_highest_offset) {
14417                                         ndr->relative_highest_offset = ndr->offset;
14418                                 }
14419                                 ndr->offset = _relative_save_offset;
14420                         }
14421                         ndr->flags = _flags_save_string;
14422                 }
14423                 {
14424                         uint32_t _flags_save_string = ndr->flags;
14425                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14426                         if (r->default_datatype) {
14427                                 uint32_t _relative_save_offset;
14428                                 _relative_save_offset = ndr->offset;
14429                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
14430                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14431                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
14432                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
14433                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
14434                                 if (ndr->offset > ndr->relative_highest_offset) {
14435                                         ndr->relative_highest_offset = ndr->offset;
14436                                 }
14437                                 ndr->offset = _relative_save_offset;
14438                         }
14439                         ndr->flags = _flags_save_string;
14440                 }
14441                 {
14442                         uint32_t _flags_save_string_array = ndr->flags;
14443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14444                         if (r->previous_names) {
14445                                 uint32_t _relative_save_offset;
14446                                 _relative_save_offset = ndr->offset;
14447                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
14448                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
14449                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
14450                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
14451                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
14452                                 if (ndr->offset > ndr->relative_highest_offset) {
14453                                         ndr->relative_highest_offset = ndr->offset;
14454                                 }
14455                                 ndr->offset = _relative_save_offset;
14456                         }
14457                         ndr->flags = _flags_save_string_array;
14458                 }
14459                 {
14460                         uint32_t _flags_save_string = ndr->flags;
14461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14462                         if (r->manufacturer_name) {
14463                                 uint32_t _relative_save_offset;
14464                                 _relative_save_offset = ndr->offset;
14465                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
14466                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14467                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
14468                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
14469                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
14470                                 if (ndr->offset > ndr->relative_highest_offset) {
14471                                         ndr->relative_highest_offset = ndr->offset;
14472                                 }
14473                                 ndr->offset = _relative_save_offset;
14474                         }
14475                         ndr->flags = _flags_save_string;
14476                 }
14477                 {
14478                         uint32_t _flags_save_string = ndr->flags;
14479                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14480                         if (r->manufacturer_url) {
14481                                 uint32_t _relative_save_offset;
14482                                 _relative_save_offset = ndr->offset;
14483                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
14484                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
14485                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
14486                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
14487                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
14488                                 if (ndr->offset > ndr->relative_highest_offset) {
14489                                         ndr->relative_highest_offset = ndr->offset;
14490                                 }
14491                                 ndr->offset = _relative_save_offset;
14492                         }
14493                         ndr->flags = _flags_save_string;
14494                 }
14495                 {
14496                         uint32_t _flags_save_string = ndr->flags;
14497                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14498                         if (r->hardware_id) {
14499                                 uint32_t _relative_save_offset;
14500                                 _relative_save_offset = ndr->offset;
14501                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
14502                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
14503                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
14504                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
14505                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
14506                                 if (ndr->offset > ndr->relative_highest_offset) {
14507                                         ndr->relative_highest_offset = ndr->offset;
14508                                 }
14509                                 ndr->offset = _relative_save_offset;
14510                         }
14511                         ndr->flags = _flags_save_string;
14512                 }
14513                 {
14514                         uint32_t _flags_save_string = ndr->flags;
14515                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14516                         if (r->provider) {
14517                                 uint32_t _relative_save_offset;
14518                                 _relative_save_offset = ndr->offset;
14519                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
14520                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
14521                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
14522                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
14523                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
14524                                 if (ndr->offset > ndr->relative_highest_offset) {
14525                                         ndr->relative_highest_offset = ndr->offset;
14526                                 }
14527                                 ndr->offset = _relative_save_offset;
14528                         }
14529                         ndr->flags = _flags_save_string;
14530                 }
14531                 {
14532                         uint32_t _flags_save_string = ndr->flags;
14533                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14534                         if (r->print_processor) {
14535                                 uint32_t _relative_save_offset;
14536                                 _relative_save_offset = ndr->offset;
14537                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
14538                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
14539                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
14540                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
14541                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
14542                                 if (ndr->offset > ndr->relative_highest_offset) {
14543                                         ndr->relative_highest_offset = ndr->offset;
14544                                 }
14545                                 ndr->offset = _relative_save_offset;
14546                         }
14547                         ndr->flags = _flags_save_string;
14548                 }
14549                 {
14550                         uint32_t _flags_save_string = ndr->flags;
14551                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14552                         if (r->vendor_setup) {
14553                                 uint32_t _relative_save_offset;
14554                                 _relative_save_offset = ndr->offset;
14555                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
14556                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
14557                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
14558                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
14559                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
14560                                 if (ndr->offset > ndr->relative_highest_offset) {
14561                                         ndr->relative_highest_offset = ndr->offset;
14562                                 }
14563                                 ndr->offset = _relative_save_offset;
14564                         }
14565                         ndr->flags = _flags_save_string;
14566                 }
14567                 {
14568                         uint32_t _flags_save_string_array = ndr->flags;
14569                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14570                         if (r->color_profiles) {
14571                                 uint32_t _relative_save_offset;
14572                                 _relative_save_offset = ndr->offset;
14573                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
14574                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
14575                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
14576                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
14577                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
14578                                 if (ndr->offset > ndr->relative_highest_offset) {
14579                                         ndr->relative_highest_offset = ndr->offset;
14580                                 }
14581                                 ndr->offset = _relative_save_offset;
14582                         }
14583                         ndr->flags = _flags_save_string_array;
14584                 }
14585                 {
14586                         uint32_t _flags_save_string = ndr->flags;
14587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14588                         if (r->inf_path) {
14589                                 uint32_t _relative_save_offset;
14590                                 _relative_save_offset = ndr->offset;
14591                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
14592                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
14593                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
14594                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
14595                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
14596                                 if (ndr->offset > ndr->relative_highest_offset) {
14597                                         ndr->relative_highest_offset = ndr->offset;
14598                                 }
14599                                 ndr->offset = _relative_save_offset;
14600                         }
14601                         ndr->flags = _flags_save_string;
14602                 }
14603                 {
14604                         uint32_t _flags_save_string_array = ndr->flags;
14605                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14606                         if (r->core_driver_dependencies) {
14607                                 uint32_t _relative_save_offset;
14608                                 _relative_save_offset = ndr->offset;
14609                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
14610                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
14611                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
14612                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
14613                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
14614                                 if (ndr->offset > ndr->relative_highest_offset) {
14615                                         ndr->relative_highest_offset = ndr->offset;
14616                                 }
14617                                 ndr->offset = _relative_save_offset;
14618                         }
14619                         ndr->flags = _flags_save_string_array;
14620                 }
14621         }
14622         return NDR_ERR_SUCCESS;
14623 }
14624
14625 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
14626 {
14627         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
14628         ndr->depth++;
14629         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14630         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14631         ndr->depth++;
14632         if (r->driver_name) {
14633                 ndr_print_string(ndr, "driver_name", r->driver_name);
14634         }
14635         ndr->depth--;
14636         ndr_print_ptr(ndr, "architecture", r->architecture);
14637         ndr->depth++;
14638         if (r->architecture) {
14639                 ndr_print_string(ndr, "architecture", r->architecture);
14640         }
14641         ndr->depth--;
14642         ndr_print_ptr(ndr, "driver_path", r->driver_path);
14643         ndr->depth++;
14644         if (r->driver_path) {
14645                 ndr_print_string(ndr, "driver_path", r->driver_path);
14646         }
14647         ndr->depth--;
14648         ndr_print_ptr(ndr, "data_file", r->data_file);
14649         ndr->depth++;
14650         if (r->data_file) {
14651                 ndr_print_string(ndr, "data_file", r->data_file);
14652         }
14653         ndr->depth--;
14654         ndr_print_ptr(ndr, "config_file", r->config_file);
14655         ndr->depth++;
14656         if (r->config_file) {
14657                 ndr_print_string(ndr, "config_file", r->config_file);
14658         }
14659         ndr->depth--;
14660         ndr_print_ptr(ndr, "help_file", r->help_file);
14661         ndr->depth++;
14662         if (r->help_file) {
14663                 ndr_print_string(ndr, "help_file", r->help_file);
14664         }
14665         ndr->depth--;
14666         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
14667         ndr->depth++;
14668         if (r->dependent_files) {
14669                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
14670         }
14671         ndr->depth--;
14672         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14673         ndr->depth++;
14674         if (r->monitor_name) {
14675                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14676         }
14677         ndr->depth--;
14678         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14679         ndr->depth++;
14680         if (r->default_datatype) {
14681                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14682         }
14683         ndr->depth--;
14684         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14685         ndr->depth++;
14686         if (r->previous_names) {
14687                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14688         }
14689         ndr->depth--;
14690         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14691         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14692         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14693         ndr->depth++;
14694         if (r->manufacturer_name) {
14695                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14696         }
14697         ndr->depth--;
14698         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14699         ndr->depth++;
14700         if (r->manufacturer_url) {
14701                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14702         }
14703         ndr->depth--;
14704         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14705         ndr->depth++;
14706         if (r->hardware_id) {
14707                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14708         }
14709         ndr->depth--;
14710         ndr_print_ptr(ndr, "provider", r->provider);
14711         ndr->depth++;
14712         if (r->provider) {
14713                 ndr_print_string(ndr, "provider", r->provider);
14714         }
14715         ndr->depth--;
14716         ndr_print_ptr(ndr, "print_processor", r->print_processor);
14717         ndr->depth++;
14718         if (r->print_processor) {
14719                 ndr_print_string(ndr, "print_processor", r->print_processor);
14720         }
14721         ndr->depth--;
14722         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
14723         ndr->depth++;
14724         if (r->vendor_setup) {
14725                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
14726         }
14727         ndr->depth--;
14728         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
14729         ndr->depth++;
14730         if (r->color_profiles) {
14731                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
14732         }
14733         ndr->depth--;
14734         ndr_print_ptr(ndr, "inf_path", r->inf_path);
14735         ndr->depth++;
14736         if (r->inf_path) {
14737                 ndr_print_string(ndr, "inf_path", r->inf_path);
14738         }
14739         ndr->depth--;
14740         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
14741         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14742         ndr->depth++;
14743         if (r->core_driver_dependencies) {
14744                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14745         }
14746         ndr->depth--;
14747         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
14748         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
14749         ndr->depth--;
14750 }
14751
14752 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
14753 {
14754         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
14755 }
14756
14757 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
14758 {
14759         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
14760         return NDR_ERR_SUCCESS;
14761 }
14762
14763 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
14764 {
14765         uint32_t v;
14766         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
14767         *r = v;
14768         return NDR_ERR_SUCCESS;
14769 }
14770
14771 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
14772 {
14773         const char *val = NULL;
14774
14775         switch (r) {
14776                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
14777                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
14778                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
14779                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
14780                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
14781         }
14782         ndr_print_enum(ndr, name, "ENUM", val, r);
14783 }
14784
14785 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
14786 {
14787         if (ndr_flags & NDR_SCALARS) {
14788                 NDR_CHECK(ndr_push_align(ndr, 5));
14789                 {
14790                         uint32_t _flags_save_string = ndr->flags;
14791                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14792                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
14793                         ndr->flags = _flags_save_string;
14794                 }
14795                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
14796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
14797                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
14798         }
14799         if (ndr_flags & NDR_BUFFERS) {
14800                 {
14801                         uint32_t _flags_save_string = ndr->flags;
14802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14803                         if (r->file_name) {
14804                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->file_name));
14805                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
14806                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->file_name));
14807                         }
14808                         ndr->flags = _flags_save_string;
14809                 }
14810         }
14811         return NDR_ERR_SUCCESS;
14812 }
14813
14814 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
14815 {
14816         uint32_t _ptr_file_name;
14817         TALLOC_CTX *_mem_save_file_name_0;
14818         if (ndr_flags & NDR_SCALARS) {
14819                 NDR_CHECK(ndr_pull_align(ndr, 5));
14820                 {
14821                         uint32_t _flags_save_string = ndr->flags;
14822                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14823                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
14824                         if (_ptr_file_name) {
14825                                 NDR_PULL_ALLOC(ndr, r->file_name);
14826                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
14827                         } else {
14828                                 r->file_name = NULL;
14829                         }
14830                         ndr->flags = _flags_save_string;
14831                 }
14832                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
14833                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
14834                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
14835         }
14836         if (ndr_flags & NDR_BUFFERS) {
14837                 {
14838                         uint32_t _flags_save_string = ndr->flags;
14839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14840                         if (r->file_name) {
14841                                 uint32_t _relative_save_offset;
14842                                 _relative_save_offset = ndr->offset;
14843                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
14844                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14845                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
14846                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
14847                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
14848                                 if (ndr->offset > ndr->relative_highest_offset) {
14849                                         ndr->relative_highest_offset = ndr->offset;
14850                                 }
14851                                 ndr->offset = _relative_save_offset;
14852                         }
14853                         ndr->flags = _flags_save_string;
14854                 }
14855         }
14856         return NDR_ERR_SUCCESS;
14857 }
14858
14859 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
14860 {
14861         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
14862         ndr->depth++;
14863         ndr_print_ptr(ndr, "file_name", r->file_name);
14864         ndr->depth++;
14865         if (r->file_name) {
14866                 ndr_print_string(ndr, "file_name", r->file_name);
14867         }
14868         ndr->depth--;
14869         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
14870         ndr_print_uint32(ndr, "file_version", r->file_version);
14871         ndr->depth--;
14872 }
14873
14874 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
14875 {
14876         uint32_t cntr_file_info_1;
14877         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
14878         ndr->depth++;
14879         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14880         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14881         ndr->depth++;
14882         if (r->driver_name) {
14883                 ndr_print_string(ndr, "driver_name", r->driver_name);
14884         }
14885         ndr->depth--;
14886         ndr_print_ptr(ndr, "architecture", r->architecture);
14887         ndr->depth++;
14888         if (r->architecture) {
14889                 ndr_print_string(ndr, "architecture", r->architecture);
14890         }
14891         ndr->depth--;
14892         ndr_print_ptr(ndr, "file_info", r->file_info);
14893         ndr->depth++;
14894         if (r->file_info) {
14895                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
14896                 ndr->depth++;
14897                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
14898                         char *idx_1=NULL;
14899                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
14900                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
14901                                 free(idx_1);
14902                         }
14903                 }
14904                 ndr->depth--;
14905         }
14906         ndr->depth--;
14907         ndr_print_uint32(ndr, "file_count", r->file_count);
14908         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14909         ndr->depth++;
14910         if (r->monitor_name) {
14911                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14912         }
14913         ndr->depth--;
14914         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14915         ndr->depth++;
14916         if (r->default_datatype) {
14917                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14918         }
14919         ndr->depth--;
14920         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14921         ndr->depth++;
14922         if (r->previous_names) {
14923                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14924         }
14925         ndr->depth--;
14926         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14927         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14928         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14929         ndr->depth++;
14930         if (r->manufacturer_name) {
14931                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14932         }
14933         ndr->depth--;
14934         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14935         ndr->depth++;
14936         if (r->manufacturer_url) {
14937                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14938         }
14939         ndr->depth--;
14940         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14941         ndr->depth++;
14942         if (r->hardware_id) {
14943                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14944         }
14945         ndr->depth--;
14946         ndr_print_ptr(ndr, "provider", r->provider);
14947         ndr->depth++;
14948         if (r->provider) {
14949                 ndr_print_string(ndr, "provider", r->provider);
14950         }
14951         ndr->depth--;
14952         ndr->depth--;
14953 }
14954
14955 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
14956 {
14957         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
14958 }
14959
14960 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
14961 {
14962         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14963         {
14964                 uint32_t _flags_save_UNION = ndr->flags;
14965                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14966                 if (ndr_flags & NDR_SCALARS) {
14967                         int level = ndr_push_get_switch_value(ndr, r);
14968                         NDR_CHECK(ndr_push_union_align(ndr, 8));
14969                         switch (level) {
14970                                 case 1: {
14971                                         NDR_CHECK(ndr_push_align(ndr, 5));
14972                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14973                                         NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14974                                 break; }
14975
14976                                 case 2: {
14977                                         NDR_CHECK(ndr_push_align(ndr, 5));
14978                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14979                                         NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14980                                 break; }
14981
14982                                 case 3: {
14983                                         NDR_CHECK(ndr_push_align(ndr, 5));
14984                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14985                                         NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14986                                 break; }
14987
14988                                 case 4: {
14989                                         NDR_CHECK(ndr_push_align(ndr, 5));
14990                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14991                                         NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14992                                 break; }
14993
14994                                 case 5: {
14995                                         NDR_CHECK(ndr_push_align(ndr, 5));
14996                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14997                                         NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14998                                 break; }
14999
15000                                 case 6: {
15001                                         NDR_CHECK(ndr_push_align(ndr, 8));
15002                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15003                                         NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
15004                                 break; }
15005
15006                                 case 7: {
15007                                         NDR_CHECK(ndr_push_align(ndr, 5));
15008                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15009                                         NDR_CHECK(ndr_push_spoolss_DriverInfo7(ndr, NDR_SCALARS, &r->info7));
15010                                 break; }
15011
15012                                 case 8: {
15013                                         NDR_CHECK(ndr_push_align(ndr, 8));
15014                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15015                                         NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
15016                                 break; }
15017
15018                                 case 101: {
15019                                         NDR_CHECK(ndr_push_align(ndr, 8));
15020                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15021                                         NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
15022                                 break; }
15023
15024                                 default: {
15025                                 break; }
15026
15027                         }
15028                 }
15029                 if (ndr_flags & NDR_BUFFERS) {
15030                         int level = ndr_push_get_switch_value(ndr, r);
15031                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15032                         switch (level) {
15033                                 case 1:
15034                                         NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
15035                                 break;
15036
15037                                 case 2:
15038                                         NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
15039                                 break;
15040
15041                                 case 3:
15042                                         NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
15043                                 break;
15044
15045                                 case 4:
15046                                         NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
15047                                 break;
15048
15049                                 case 5:
15050                                         NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
15051                                 break;
15052
15053                                 case 6:
15054                                         NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
15055                                 break;
15056
15057                                 case 7:
15058                                         NDR_CHECK(ndr_push_spoolss_DriverInfo7(ndr, NDR_BUFFERS, &r->info7));
15059                                 break;
15060
15061                                 case 8:
15062                                         NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
15063                                 break;
15064
15065                                 case 101:
15066                                         NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
15067                                 break;
15068
15069                                 default:
15070                                 break;
15071
15072                         }
15073                 }
15074                 ndr->flags = _flags_save_UNION;
15075         }
15076         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15077         return NDR_ERR_SUCCESS;
15078 }
15079
15080 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
15081 {
15082         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15083         int level;
15084         {
15085                 uint32_t _flags_save_UNION = ndr->flags;
15086                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15087                 level = ndr_pull_get_switch_value(ndr, r);
15088                 if (ndr_flags & NDR_SCALARS) {
15089                         NDR_CHECK(ndr_pull_union_align(ndr, 8));
15090                         switch (level) {
15091                                 case 1: {
15092                                         NDR_CHECK(ndr_pull_align(ndr, 5));
15093                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15094                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
15095                                 break; }
15096
15097                                 case 2: {
15098                                         NDR_CHECK(ndr_pull_align(ndr, 5));
15099                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15100                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
15101                                 break; }
15102
15103                                 case 3: {
15104                                         NDR_CHECK(ndr_pull_align(ndr, 5));
15105                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15106                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
15107                                 break; }
15108
15109                                 case 4: {
15110                                         NDR_CHECK(ndr_pull_align(ndr, 5));
15111                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15112                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
15113                                 break; }
15114
15115                                 case 5: {
15116                                         NDR_CHECK(ndr_pull_align(ndr, 5));
15117                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15118                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
15119                                 break; }
15120
15121                                 case 6: {
15122                                         NDR_CHECK(ndr_pull_align(ndr, 8));
15123                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15124                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
15125                                 break; }
15126
15127                                 case 7: {
15128                                         NDR_CHECK(ndr_pull_align(ndr, 5));
15129                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15130                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo7(ndr, NDR_SCALARS, &r->info7));
15131                                 break; }
15132
15133                                 case 8: {
15134                                         NDR_CHECK(ndr_pull_align(ndr, 8));
15135                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15136                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
15137                                 break; }
15138
15139                                 case 101: {
15140                                         NDR_CHECK(ndr_pull_align(ndr, 8));
15141                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15142                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
15143                                 break; }
15144
15145                                 default: {
15146                                 break; }
15147
15148                         }
15149                 }
15150                 if (ndr_flags & NDR_BUFFERS) {
15151                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15152                         switch (level) {
15153                                 case 1:
15154                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
15155                                 break;
15156
15157                                 case 2:
15158                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
15159                                 break;
15160
15161                                 case 3:
15162                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
15163                                 break;
15164
15165                                 case 4:
15166                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
15167                                 break;
15168
15169                                 case 5:
15170                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
15171                                 break;
15172
15173                                 case 6:
15174                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
15175                                 break;
15176
15177                                 case 7:
15178                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo7(ndr, NDR_BUFFERS, &r->info7));
15179                                 break;
15180
15181                                 case 8:
15182                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
15183                                 break;
15184
15185                                 case 101:
15186                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
15187                                 break;
15188
15189                                 default:
15190                                 break;
15191
15192                         }
15193                 }
15194                 ndr->flags = _flags_save_UNION;
15195         }
15196         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15197         return NDR_ERR_SUCCESS;
15198 }
15199
15200 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
15201 {
15202         int level;
15203         {
15204                 uint32_t _flags_save_UNION = ndr->flags;
15205                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15206                 level = ndr_print_get_switch_value(ndr, r);
15207                 ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
15208                 switch (level) {
15209                         case 1:
15210                                 ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
15211                         break;
15212
15213                         case 2:
15214                                 ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
15215                         break;
15216
15217                         case 3:
15218                                 ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
15219                         break;
15220
15221                         case 4:
15222                                 ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
15223                         break;
15224
15225                         case 5:
15226                                 ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
15227                         break;
15228
15229                         case 6:
15230                                 ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
15231                         break;
15232
15233                         case 7:
15234                                 ndr_print_spoolss_DriverInfo7(ndr, "info7", &r->info7);
15235                         break;
15236
15237                         case 8:
15238                                 ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
15239                         break;
15240
15241                         case 101:
15242                                 ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
15243                         break;
15244
15245                         default:
15246                         break;
15247
15248                 }
15249                 ndr->flags = _flags_save_UNION;
15250         }
15251 }
15252
15253 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15254 {
15255         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
15256         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
15257 }
15258
15259 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
15260 {
15261         if (ndr_flags & NDR_SCALARS) {
15262                 NDR_CHECK(ndr_push_align(ndr, 4));
15263                 {
15264                         uint32_t _flags_save_string = ndr->flags;
15265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15266                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
15267                         ndr->flags = _flags_save_string;
15268                 }
15269                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15270         }
15271         if (ndr_flags & NDR_BUFFERS) {
15272         }
15273         return NDR_ERR_SUCCESS;
15274 }
15275
15276 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
15277 {
15278         if (ndr_flags & NDR_SCALARS) {
15279                 NDR_CHECK(ndr_pull_align(ndr, 4));
15280                 {
15281                         uint32_t _flags_save_string = ndr->flags;
15282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15283                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
15284                         ndr->flags = _flags_save_string;
15285                 }
15286                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15287         }
15288         if (ndr_flags & NDR_BUFFERS) {
15289         }
15290         return NDR_ERR_SUCCESS;
15291 }
15292
15293 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
15294 {
15295         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
15296         ndr->depth++;
15297         ndr_print_string(ndr, "directory_name", r->directory_name);
15298         ndr->depth--;
15299 }
15300
15301 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15302 {
15303         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
15304 }
15305
15306 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
15307 {
15308         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15309         {
15310                 uint32_t _flags_save_UNION = ndr->flags;
15311                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15312                 if (ndr_flags & NDR_SCALARS) {
15313                         int level = ndr_push_get_switch_value(ndr, r);
15314                         NDR_CHECK(ndr_push_union_align(ndr, 4));
15315                         switch (level) {
15316                                 case 1: {
15317                                         NDR_CHECK(ndr_push_align(ndr, 4));
15318                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15319                                         NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15320                                 break; }
15321
15322                                 default: {
15323                                         NDR_CHECK(ndr_push_align(ndr, 4));
15324                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15325                                         NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15326                                 break; }
15327
15328                         }
15329                 }
15330                 if (ndr_flags & NDR_BUFFERS) {
15331                         int level = ndr_push_get_switch_value(ndr, r);
15332                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15333                         switch (level) {
15334                                 case 1:
15335                                 break;
15336
15337                                 default:
15338                                 break;
15339
15340                         }
15341                 }
15342                 ndr->flags = _flags_save_UNION;
15343         }
15344         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15345         return NDR_ERR_SUCCESS;
15346 }
15347
15348 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
15349 {
15350         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15351         int level;
15352         {
15353                 uint32_t _flags_save_UNION = ndr->flags;
15354                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15355                 level = ndr_pull_get_switch_value(ndr, r);
15356                 if (ndr_flags & NDR_SCALARS) {
15357                         NDR_CHECK(ndr_pull_union_align(ndr, 4));
15358                         switch (level) {
15359                                 case 1: {
15360                                         NDR_CHECK(ndr_pull_align(ndr, 4));
15361                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15362                                         NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15363                                 break; }
15364
15365                                 default: {
15366                                         NDR_CHECK(ndr_pull_align(ndr, 4));
15367                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15368                                         NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15369                                 break; }
15370
15371                         }
15372                 }
15373                 if (ndr_flags & NDR_BUFFERS) {
15374                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15375                         switch (level) {
15376                                 case 1:
15377                                 break;
15378
15379                                 default:
15380                                 break;
15381
15382                         }
15383                 }
15384                 ndr->flags = _flags_save_UNION;
15385         }
15386         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15387         return NDR_ERR_SUCCESS;
15388 }
15389
15390 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
15391 {
15392         int level;
15393         {
15394                 uint32_t _flags_save_UNION = ndr->flags;
15395                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15396                 level = ndr_print_get_switch_value(ndr, r);
15397                 ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
15398                 switch (level) {
15399                         case 1:
15400                                 ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
15401                         break;
15402
15403                         default:
15404                                 ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
15405                         break;
15406
15407                 }
15408                 ndr->flags = _flags_save_UNION;
15409         }
15410 }
15411
15412 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15413 {
15414         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
15415         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
15416 }
15417
15418 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
15419 {
15420         if (ndr_flags & NDR_SCALARS) {
15421                 NDR_CHECK(ndr_push_align(ndr, 5));
15422                 {
15423                         uint32_t _flags_save_string = ndr->flags;
15424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15425                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
15426                         ndr->flags = _flags_save_string;
15427                 }
15428                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15429         }
15430         if (ndr_flags & NDR_BUFFERS) {
15431                 {
15432                         uint32_t _flags_save_string = ndr->flags;
15433                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15434                         if (r->print_processor_name) {
15435                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor_name));
15436                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
15437                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor_name));
15438                         }
15439                         ndr->flags = _flags_save_string;
15440                 }
15441         }
15442         return NDR_ERR_SUCCESS;
15443 }
15444
15445 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
15446 {
15447         uint32_t _ptr_print_processor_name;
15448         TALLOC_CTX *_mem_save_print_processor_name_0;
15449         if (ndr_flags & NDR_SCALARS) {
15450                 NDR_CHECK(ndr_pull_align(ndr, 5));
15451                 {
15452                         uint32_t _flags_save_string = ndr->flags;
15453                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15454                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
15455                         if (_ptr_print_processor_name) {
15456                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
15457                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
15458                         } else {
15459                                 r->print_processor_name = NULL;
15460                         }
15461                         ndr->flags = _flags_save_string;
15462                 }
15463                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15464         }
15465         if (ndr_flags & NDR_BUFFERS) {
15466                 {
15467                         uint32_t _flags_save_string = ndr->flags;
15468                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15469                         if (r->print_processor_name) {
15470                                 uint32_t _relative_save_offset;
15471                                 _relative_save_offset = ndr->offset;
15472                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
15473                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15474                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
15475                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
15476                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
15477                                 if (ndr->offset > ndr->relative_highest_offset) {
15478                                         ndr->relative_highest_offset = ndr->offset;
15479                                 }
15480                                 ndr->offset = _relative_save_offset;
15481                         }
15482                         ndr->flags = _flags_save_string;
15483                 }
15484         }
15485         return NDR_ERR_SUCCESS;
15486 }
15487
15488 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
15489 {
15490         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
15491         ndr->depth++;
15492         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
15493         ndr->depth++;
15494         if (r->print_processor_name) {
15495                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
15496         }
15497         ndr->depth--;
15498         ndr->depth--;
15499 }
15500
15501 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15502 {
15503         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
15504 }
15505
15506 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
15507 {
15508         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15509         {
15510                 uint32_t _flags_save_UNION = ndr->flags;
15511                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15512                 if (ndr_flags & NDR_SCALARS) {
15513                         int level = ndr_push_get_switch_value(ndr, r);
15514                         NDR_CHECK(ndr_push_union_align(ndr, 5));
15515                         switch (level) {
15516                                 case 1: {
15517                                         NDR_CHECK(ndr_push_align(ndr, 5));
15518                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15519                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
15520                                 break; }
15521
15522                                 default: {
15523                                 break; }
15524
15525                         }
15526                 }
15527                 if (ndr_flags & NDR_BUFFERS) {
15528                         int level = ndr_push_get_switch_value(ndr, r);
15529                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15530                         switch (level) {
15531                                 case 1:
15532                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
15533                                 break;
15534
15535                                 default:
15536                                 break;
15537
15538                         }
15539                 }
15540                 ndr->flags = _flags_save_UNION;
15541         }
15542         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15543         return NDR_ERR_SUCCESS;
15544 }
15545
15546 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
15547 {
15548         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15549         int level;
15550         {
15551                 uint32_t _flags_save_UNION = ndr->flags;
15552                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15553                 level = ndr_pull_get_switch_value(ndr, r);
15554                 if (ndr_flags & NDR_SCALARS) {
15555                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
15556                         switch (level) {
15557                                 case 1: {
15558                                         NDR_CHECK(ndr_pull_align(ndr, 5));
15559                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15560                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
15561                                 break; }
15562
15563                                 default: {
15564                                 break; }
15565
15566                         }
15567                 }
15568                 if (ndr_flags & NDR_BUFFERS) {
15569                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15570                         switch (level) {
15571                                 case 1:
15572                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
15573                                 break;
15574
15575                                 default:
15576                                 break;
15577
15578                         }
15579                 }
15580                 ndr->flags = _flags_save_UNION;
15581         }
15582         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15583         return NDR_ERR_SUCCESS;
15584 }
15585
15586 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
15587 {
15588         int level;
15589         {
15590                 uint32_t _flags_save_UNION = ndr->flags;
15591                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15592                 level = ndr_print_get_switch_value(ndr, r);
15593                 ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
15594                 switch (level) {
15595                         case 1:
15596                                 ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
15597                         break;
15598
15599                         default:
15600                         break;
15601
15602                 }
15603                 ndr->flags = _flags_save_UNION;
15604         }
15605 }
15606
15607 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
15608 {
15609         if (ndr_flags & NDR_SCALARS) {
15610                 NDR_CHECK(ndr_push_align(ndr, 4));
15611                 {
15612                         uint32_t _flags_save_string = ndr->flags;
15613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15614                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
15615                         ndr->flags = _flags_save_string;
15616                 }
15617                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15618         }
15619         if (ndr_flags & NDR_BUFFERS) {
15620         }
15621         return NDR_ERR_SUCCESS;
15622 }
15623
15624 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
15625 {
15626         if (ndr_flags & NDR_SCALARS) {
15627                 NDR_CHECK(ndr_pull_align(ndr, 4));
15628                 {
15629                         uint32_t _flags_save_string = ndr->flags;
15630                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15631                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
15632                         ndr->flags = _flags_save_string;
15633                 }
15634                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15635         }
15636         if (ndr_flags & NDR_BUFFERS) {
15637         }
15638         return NDR_ERR_SUCCESS;
15639 }
15640
15641 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
15642 {
15643         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
15644         ndr->depth++;
15645         ndr_print_string(ndr, "directory_name", r->directory_name);
15646         ndr->depth--;
15647 }
15648
15649 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15650 {
15651         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
15652 }
15653
15654 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
15655 {
15656         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15657         {
15658                 uint32_t _flags_save_UNION = ndr->flags;
15659                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15660                 if (ndr_flags & NDR_SCALARS) {
15661                         int level = ndr_push_get_switch_value(ndr, r);
15662                         NDR_CHECK(ndr_push_union_align(ndr, 4));
15663                         switch (level) {
15664                                 case 1: {
15665                                         NDR_CHECK(ndr_push_align(ndr, 4));
15666                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15667                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15668                                 break; }
15669
15670                                 default: {
15671                                         NDR_CHECK(ndr_push_align(ndr, 4));
15672                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15673                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15674                                 break; }
15675
15676                         }
15677                 }
15678                 if (ndr_flags & NDR_BUFFERS) {
15679                         int level = ndr_push_get_switch_value(ndr, r);
15680                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15681                         switch (level) {
15682                                 case 1:
15683                                 break;
15684
15685                                 default:
15686                                 break;
15687
15688                         }
15689                 }
15690                 ndr->flags = _flags_save_UNION;
15691         }
15692         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15693         return NDR_ERR_SUCCESS;
15694 }
15695
15696 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
15697 {
15698         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15699         int level;
15700         {
15701                 uint32_t _flags_save_UNION = ndr->flags;
15702                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15703                 level = ndr_pull_get_switch_value(ndr, r);
15704                 if (ndr_flags & NDR_SCALARS) {
15705                         NDR_CHECK(ndr_pull_union_align(ndr, 4));
15706                         switch (level) {
15707                                 case 1: {
15708                                         NDR_CHECK(ndr_pull_align(ndr, 4));
15709                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15710                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15711                                 break; }
15712
15713                                 default: {
15714                                         NDR_CHECK(ndr_pull_align(ndr, 4));
15715                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15716                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15717                                 break; }
15718
15719                         }
15720                 }
15721                 if (ndr_flags & NDR_BUFFERS) {
15722                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15723                         switch (level) {
15724                                 case 1:
15725                                 break;
15726
15727                                 default:
15728                                 break;
15729
15730                         }
15731                 }
15732                 ndr->flags = _flags_save_UNION;
15733         }
15734         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15735         return NDR_ERR_SUCCESS;
15736 }
15737
15738 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
15739 {
15740         int level;
15741         {
15742                 uint32_t _flags_save_UNION = ndr->flags;
15743                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15744                 level = ndr_print_get_switch_value(ndr, r);
15745                 ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
15746                 switch (level) {
15747                         case 1:
15748                                 ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15749                         break;
15750
15751                         default:
15752                                 ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15753                         break;
15754
15755                 }
15756                 ndr->flags = _flags_save_UNION;
15757         }
15758 }
15759
15760 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15761 {
15762         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
15763         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
15764 }
15765
15766 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
15767 {
15768         if (ndr_flags & NDR_SCALARS) {
15769                 NDR_CHECK(ndr_push_align(ndr, 5));
15770                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
15771                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
15772                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
15773                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15774         }
15775         if (ndr_flags & NDR_BUFFERS) {
15776                 if (r->document_name) {
15777                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15778                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15779                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15780                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15781                 }
15782                 if (r->output_file) {
15783                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15784                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15785                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15786                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15787                 }
15788                 if (r->datatype) {
15789                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15790                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15791                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15792                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15793                 }
15794         }
15795         return NDR_ERR_SUCCESS;
15796 }
15797
15798 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
15799 {
15800         uint32_t _ptr_document_name;
15801         TALLOC_CTX *_mem_save_document_name_0;
15802         uint32_t _ptr_output_file;
15803         TALLOC_CTX *_mem_save_output_file_0;
15804         uint32_t _ptr_datatype;
15805         TALLOC_CTX *_mem_save_datatype_0;
15806         if (ndr_flags & NDR_SCALARS) {
15807                 NDR_CHECK(ndr_pull_align(ndr, 5));
15808                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
15809                 if (_ptr_document_name) {
15810                         NDR_PULL_ALLOC(ndr, r->document_name);
15811                 } else {
15812                         r->document_name = NULL;
15813                 }
15814                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
15815                 if (_ptr_output_file) {
15816                         NDR_PULL_ALLOC(ndr, r->output_file);
15817                 } else {
15818                         r->output_file = NULL;
15819                 }
15820                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
15821                 if (_ptr_datatype) {
15822                         NDR_PULL_ALLOC(ndr, r->datatype);
15823                 } else {
15824                         r->datatype = NULL;
15825                 }
15826                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15827         }
15828         if (ndr_flags & NDR_BUFFERS) {
15829                 if (r->document_name) {
15830                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15831                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
15832                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
15833                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
15834                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
15835                                 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));
15836                         }
15837                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
15838                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
15839                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
15840                 }
15841                 if (r->output_file) {
15842                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
15843                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
15844                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
15845                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
15846                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
15847                                 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));
15848                         }
15849                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
15850                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
15851                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
15852                 }
15853                 if (r->datatype) {
15854                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
15855                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
15856                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
15857                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
15858                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
15859                                 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));
15860                         }
15861                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
15862                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
15863                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
15864                 }
15865         }
15866         return NDR_ERR_SUCCESS;
15867 }
15868
15869 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
15870 {
15871         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
15872         ndr->depth++;
15873         ndr_print_ptr(ndr, "document_name", r->document_name);
15874         ndr->depth++;
15875         if (r->document_name) {
15876                 ndr_print_string(ndr, "document_name", r->document_name);
15877         }
15878         ndr->depth--;
15879         ndr_print_ptr(ndr, "output_file", r->output_file);
15880         ndr->depth++;
15881         if (r->output_file) {
15882                 ndr_print_string(ndr, "output_file", r->output_file);
15883         }
15884         ndr->depth--;
15885         ndr_print_ptr(ndr, "datatype", r->datatype);
15886         ndr->depth++;
15887         if (r->datatype) {
15888                 ndr_print_string(ndr, "datatype", r->datatype);
15889         }
15890         ndr->depth--;
15891         ndr->depth--;
15892 }
15893
15894 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
15895 {
15896         if (ndr_flags & NDR_SCALARS) {
15897                 int level = ndr_push_get_switch_value(ndr, r);
15898                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15899                 NDR_CHECK(ndr_push_union_align(ndr, 5));
15900                 switch (level) {
15901                         case 1: {
15902                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15903                         break; }
15904
15905                         case 2: {
15906                         break; }
15907
15908                         case 3: {
15909                         break; }
15910
15911                         default: {
15912                         break; }
15913
15914                 }
15915         }
15916         if (ndr_flags & NDR_BUFFERS) {
15917                 int level = ndr_push_get_switch_value(ndr, r);
15918                 switch (level) {
15919                         case 1:
15920                                 if (r->info1) {
15921                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15922                                 }
15923                         break;
15924
15925                         case 2:
15926                         break;
15927
15928                         case 3:
15929                         break;
15930
15931                         default:
15932                         break;
15933
15934                 }
15935         }
15936         return NDR_ERR_SUCCESS;
15937 }
15938
15939 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
15940 {
15941         int level;
15942         uint32_t _level;
15943         TALLOC_CTX *_mem_save_info1_0;
15944         level = ndr_pull_get_switch_value(ndr, r);
15945         if (ndr_flags & NDR_SCALARS) {
15946                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15947                 if (_level != level) {
15948                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
15949                 }
15950                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
15951                 switch (level) {
15952                         case 1: {
15953                                 uint32_t _ptr_info1;
15954                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15955                                 if (_ptr_info1) {
15956                                         NDR_PULL_ALLOC(ndr, r->info1);
15957                                 } else {
15958                                         r->info1 = NULL;
15959                                 }
15960                         break; }
15961
15962                         case 2: {
15963                         break; }
15964
15965                         case 3: {
15966                         break; }
15967
15968                         default: {
15969                         break; }
15970
15971                 }
15972         }
15973         if (ndr_flags & NDR_BUFFERS) {
15974                 switch (level) {
15975                         case 1:
15976                                 if (r->info1) {
15977                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15978                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15979                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15980                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15981                                 }
15982                         break;
15983
15984                         case 2:
15985                         break;
15986
15987                         case 3:
15988                         break;
15989
15990                         default:
15991                         break;
15992
15993                 }
15994         }
15995         return NDR_ERR_SUCCESS;
15996 }
15997
15998 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
15999 {
16000         int level;
16001         level = ndr_print_get_switch_value(ndr, r);
16002         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
16003         switch (level) {
16004                 case 1:
16005                         ndr_print_ptr(ndr, "info1", r->info1);
16006                         ndr->depth++;
16007                         if (r->info1) {
16008                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
16009                         }
16010                         ndr->depth--;
16011                 break;
16012
16013                 case 2:
16014                 break;
16015
16016                 case 3:
16017                 break;
16018
16019                 default:
16020                 break;
16021
16022         }
16023 }
16024
16025 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
16026 {
16027         if (ndr_flags & NDR_SCALARS) {
16028                 NDR_CHECK(ndr_push_align(ndr, 4));
16029                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
16030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
16031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
16032                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
16033                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
16034                 {
16035                         uint32_t _flags_save_string = ndr->flags;
16036                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16037                         {
16038                                 struct ndr_push *_ndr_extra_string;
16039                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
16040                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
16041                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
16042                         }
16043                         ndr->flags = _flags_save_string;
16044                 }
16045                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
16046         }
16047         if (ndr_flags & NDR_BUFFERS) {
16048         }
16049         return NDR_ERR_SUCCESS;
16050 }
16051
16052 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
16053 {
16054         if (ndr_flags & NDR_SCALARS) {
16055                 NDR_CHECK(ndr_pull_align(ndr, 4));
16056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
16057                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
16058                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
16059                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
16060                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
16061                 {
16062                         uint32_t _flags_save_string = ndr->flags;
16063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16064                         {
16065                                 struct ndr_pull *_ndr_extra_string;
16066                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
16067                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
16068                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
16069                         }
16070                         ndr->flags = _flags_save_string;
16071                 }
16072                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
16073         }
16074         if (ndr_flags & NDR_BUFFERS) {
16075         }
16076         return NDR_ERR_SUCCESS;
16077 }
16078
16079 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
16080 {
16081         ndr_print_struct(ndr, name, "spoolss_OSVersion");
16082         ndr->depth++;
16083         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);
16084         ndr_print_uint32(ndr, "major", r->major);
16085         ndr_print_uint32(ndr, "minor", r->minor);
16086         ndr_print_uint32(ndr, "build", r->build);
16087         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
16088         ndr_print_string(ndr, "extra_string", r->extra_string);
16089         ndr->depth--;
16090 }
16091
16092 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
16093 {
16094         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
16095 }
16096
16097 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
16098 {
16099         if (ndr_flags & NDR_SCALARS) {
16100                 NDR_CHECK(ndr_push_align(ndr, 4));
16101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
16102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
16103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
16104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
16105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
16106                 {
16107                         uint32_t _flags_save_string = ndr->flags;
16108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16109                         {
16110                                 struct ndr_push *_ndr_extra_string;
16111                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
16112                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
16113                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
16114                         }
16115                         ndr->flags = _flags_save_string;
16116                 }
16117                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_major));
16118                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_minor));
16119                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->suite_mask));
16120                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->product_type));
16121                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->reserved));
16122                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
16123         }
16124         if (ndr_flags & NDR_BUFFERS) {
16125         }
16126         return NDR_ERR_SUCCESS;
16127 }
16128
16129 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
16130 {
16131         if (ndr_flags & NDR_SCALARS) {
16132                 NDR_CHECK(ndr_pull_align(ndr, 4));
16133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
16134                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
16135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
16136                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
16137                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
16138                 {
16139                         uint32_t _flags_save_string = ndr->flags;
16140                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16141                         {
16142                                 struct ndr_pull *_ndr_extra_string;
16143                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
16144                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
16145                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
16146                         }
16147                         ndr->flags = _flags_save_string;
16148                 }
16149                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_major));
16150                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_minor));
16151                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->suite_mask));
16152                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->product_type));
16153                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->reserved));
16154                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
16155         }
16156         if (ndr_flags & NDR_BUFFERS) {
16157         }
16158         return NDR_ERR_SUCCESS;
16159 }
16160
16161 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
16162 {
16163         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
16164         ndr->depth++;
16165         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);
16166         ndr_print_uint32(ndr, "major", r->major);
16167         ndr_print_uint32(ndr, "minor", r->minor);
16168         ndr_print_uint32(ndr, "build", r->build);
16169         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
16170         ndr_print_string(ndr, "extra_string", r->extra_string);
16171         ndr_print_uint16(ndr, "service_pack_major", r->service_pack_major);
16172         ndr_print_uint16(ndr, "service_pack_minor", r->service_pack_minor);
16173         ndr_print_uint16(ndr, "suite_mask", r->suite_mask);
16174         ndr_print_uint8(ndr, "product_type", r->product_type);
16175         ndr_print_uint8(ndr, "reserved", r->reserved);
16176         ndr->depth--;
16177 }
16178
16179 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
16180 {
16181         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
16182 }
16183
16184 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
16185 {
16186         if (ndr_flags & NDR_SCALARS) {
16187                 int level = ndr_push_get_switch_value(ndr, r);
16188                 NDR_CHECK(ndr_push_union_align(ndr, 4));
16189                 switch (level) {
16190                         case REG_NONE: {
16191                         break; }
16192
16193                         case REG_SZ: {
16194                                 {
16195                                         uint32_t _flags_save_string = ndr->flags;
16196                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16197                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
16198                                         ndr->flags = _flags_save_string;
16199                                 }
16200                         break; }
16201
16202                         case REG_BINARY: {
16203                                 {
16204                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
16205                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
16206                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
16207                                         ndr->flags = _flags_save_DATA_BLOB;
16208                                 }
16209                         break; }
16210
16211                         case REG_DWORD: {
16212                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
16213                         break; }
16214
16215                         case REG_MULTI_SZ: {
16216                                 {
16217                                         uint32_t _flags_save_string_array = ndr->flags;
16218                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16219                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
16220                                         ndr->flags = _flags_save_string_array;
16221                                 }
16222                         break; }
16223
16224                         default: {
16225                                 {
16226                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
16227                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
16228                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
16229                                         ndr->flags = _flags_save_DATA_BLOB;
16230                                 }
16231                         break; }
16232
16233                 }
16234         }
16235         if (ndr_flags & NDR_BUFFERS) {
16236                 int level = ndr_push_get_switch_value(ndr, r);
16237                 switch (level) {
16238                         case REG_NONE:
16239                         break;
16240
16241                         case REG_SZ:
16242                         break;
16243
16244                         case REG_BINARY:
16245                         break;
16246
16247                         case REG_DWORD:
16248                         break;
16249
16250                         case REG_MULTI_SZ:
16251                         break;
16252
16253                         default:
16254                         break;
16255
16256                 }
16257         }
16258         return NDR_ERR_SUCCESS;
16259 }
16260
16261 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
16262 {
16263         int level;
16264         level = ndr_pull_get_switch_value(ndr, r);
16265         if (ndr_flags & NDR_SCALARS) {
16266                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
16267                 switch (level) {
16268                         case REG_NONE: {
16269                         break; }
16270
16271                         case REG_SZ: {
16272                                 {
16273                                         uint32_t _flags_save_string = ndr->flags;
16274                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16275                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
16276                                         ndr->flags = _flags_save_string;
16277                                 }
16278                         break; }
16279
16280                         case REG_BINARY: {
16281                                 {
16282                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
16283                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
16284                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
16285                                         ndr->flags = _flags_save_DATA_BLOB;
16286                                 }
16287                         break; }
16288
16289                         case REG_DWORD: {
16290                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
16291                         break; }
16292
16293                         case REG_MULTI_SZ: {
16294                                 {
16295                                         uint32_t _flags_save_string_array = ndr->flags;
16296                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16297                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
16298                                         ndr->flags = _flags_save_string_array;
16299                                 }
16300                         break; }
16301
16302                         default: {
16303                                 {
16304                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
16305                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
16306                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
16307                                         ndr->flags = _flags_save_DATA_BLOB;
16308                                 }
16309                         break; }
16310
16311                 }
16312         }
16313         if (ndr_flags & NDR_BUFFERS) {
16314                 switch (level) {
16315                         case REG_NONE:
16316                         break;
16317
16318                         case REG_SZ:
16319                         break;
16320
16321                         case REG_BINARY:
16322                         break;
16323
16324                         case REG_DWORD:
16325                         break;
16326
16327                         case REG_MULTI_SZ:
16328                         break;
16329
16330                         default:
16331                         break;
16332
16333                 }
16334         }
16335         return NDR_ERR_SUCCESS;
16336 }
16337
16338 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
16339 {
16340         int level;
16341         level = ndr_print_get_switch_value(ndr, r);
16342         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
16343         switch (level) {
16344                 case REG_NONE:
16345                 break;
16346
16347                 case REG_SZ:
16348                         ndr_print_string(ndr, "string", r->string);
16349                 break;
16350
16351                 case REG_BINARY:
16352                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
16353                 break;
16354
16355                 case REG_DWORD:
16356                         ndr_print_uint32(ndr, "value", r->value);
16357                 break;
16358
16359                 case REG_MULTI_SZ:
16360                         ndr_print_string_array(ndr, "string_array", r->string_array);
16361                 break;
16362
16363                 default:
16364                         ndr_print_DATA_BLOB(ndr, "data", r->data);
16365                 break;
16366
16367         }
16368 }
16369
16370 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
16371 {
16372         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
16373         return NDR_ERR_SUCCESS;
16374 }
16375
16376 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
16377 {
16378         uint32_t v;
16379         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
16380         *r = v;
16381         return NDR_ERR_SUCCESS;
16382 }
16383
16384 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
16385 {
16386         const char *val = NULL;
16387
16388         switch (r) {
16389                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
16390                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
16391                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
16392         }
16393         ndr_print_enum(ndr, name, "ENUM", val, r);
16394 }
16395
16396 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
16397 {
16398         if (ndr_flags & NDR_SCALARS) {
16399                 NDR_CHECK(ndr_push_align(ndr, 4));
16400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
16401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
16402                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
16403         }
16404         if (ndr_flags & NDR_BUFFERS) {
16405         }
16406         return NDR_ERR_SUCCESS;
16407 }
16408
16409 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
16410 {
16411         if (ndr_flags & NDR_SCALARS) {
16412                 NDR_CHECK(ndr_pull_align(ndr, 4));
16413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
16414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
16415                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
16416         }
16417         if (ndr_flags & NDR_BUFFERS) {
16418         }
16419         return NDR_ERR_SUCCESS;
16420 }
16421
16422 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
16423 {
16424         ndr_print_struct(ndr, name, "spoolss_FormSize");
16425         ndr->depth++;
16426         ndr_print_uint32(ndr, "width", r->width);
16427         ndr_print_uint32(ndr, "height", r->height);
16428         ndr->depth--;
16429 }
16430
16431 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
16432 {
16433         if (ndr_flags & NDR_SCALARS) {
16434                 NDR_CHECK(ndr_push_align(ndr, 4));
16435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
16436                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
16437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
16438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
16439                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
16440         }
16441         if (ndr_flags & NDR_BUFFERS) {
16442         }
16443         return NDR_ERR_SUCCESS;
16444 }
16445
16446 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
16447 {
16448         if (ndr_flags & NDR_SCALARS) {
16449                 NDR_CHECK(ndr_pull_align(ndr, 4));
16450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
16451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
16452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
16453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
16454                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
16455         }
16456         if (ndr_flags & NDR_BUFFERS) {
16457         }
16458         return NDR_ERR_SUCCESS;
16459 }
16460
16461 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
16462 {
16463         ndr_print_struct(ndr, name, "spoolss_FormArea");
16464         ndr->depth++;
16465         ndr_print_uint32(ndr, "left", r->left);
16466         ndr_print_uint32(ndr, "top", r->top);
16467         ndr_print_uint32(ndr, "right", r->right);
16468         ndr_print_uint32(ndr, "bottom", r->bottom);
16469         ndr->depth--;
16470 }
16471
16472 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
16473 {
16474         if (ndr_flags & NDR_SCALARS) {
16475                 NDR_CHECK(ndr_push_align(ndr, 5));
16476                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16477                 {
16478                         uint32_t _flags_save_string = ndr->flags;
16479                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16480                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
16481                         ndr->flags = _flags_save_string;
16482                 }
16483                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16484                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16485                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16486         }
16487         if (ndr_flags & NDR_BUFFERS) {
16488                 {
16489                         uint32_t _flags_save_string = ndr->flags;
16490                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16491                         if (r->form_name) {
16492                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->form_name));
16493                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
16494                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->form_name));
16495                         }
16496                         ndr->flags = _flags_save_string;
16497                 }
16498         }
16499         return NDR_ERR_SUCCESS;
16500 }
16501
16502 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
16503 {
16504         uint32_t _ptr_form_name;
16505         TALLOC_CTX *_mem_save_form_name_0;
16506         if (ndr_flags & NDR_SCALARS) {
16507                 NDR_CHECK(ndr_pull_align(ndr, 5));
16508                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16509                 {
16510                         uint32_t _flags_save_string = ndr->flags;
16511                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16512                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16513                         if (_ptr_form_name) {
16514                                 NDR_PULL_ALLOC(ndr, r->form_name);
16515                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
16516                         } else {
16517                                 r->form_name = NULL;
16518                         }
16519                         ndr->flags = _flags_save_string;
16520                 }
16521                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16522                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16523                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16524         }
16525         if (ndr_flags & NDR_BUFFERS) {
16526                 {
16527                         uint32_t _flags_save_string = ndr->flags;
16528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16529                         if (r->form_name) {
16530                                 uint32_t _relative_save_offset;
16531                                 _relative_save_offset = ndr->offset;
16532                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
16533                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16534                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16535                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
16536                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16537                                 if (ndr->offset > ndr->relative_highest_offset) {
16538                                         ndr->relative_highest_offset = ndr->offset;
16539                                 }
16540                                 ndr->offset = _relative_save_offset;
16541                         }
16542                         ndr->flags = _flags_save_string;
16543                 }
16544         }
16545         return NDR_ERR_SUCCESS;
16546 }
16547
16548 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
16549 {
16550         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
16551         ndr->depth++;
16552         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16553         ndr_print_ptr(ndr, "form_name", r->form_name);
16554         ndr->depth++;
16555         if (r->form_name) {
16556                 ndr_print_string(ndr, "form_name", r->form_name);
16557         }
16558         ndr->depth--;
16559         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16560         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16561         ndr->depth--;
16562 }
16563
16564 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16565 {
16566         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
16567 }
16568
16569 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16570 {
16571         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16572         return NDR_ERR_SUCCESS;
16573 }
16574
16575 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16576 {
16577         uint32_t v;
16578         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16579         *r = v;
16580         return NDR_ERR_SUCCESS;
16581 }
16582
16583 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
16584 {
16585         ndr_print_uint32(ndr, name, r);
16586         ndr->depth++;
16587         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
16588         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
16589         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
16590         ndr->depth--;
16591 }
16592
16593 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
16594 {
16595         if (ndr_flags & NDR_SCALARS) {
16596                 NDR_CHECK(ndr_push_align(ndr, 5));
16597                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16598                 {
16599                         uint32_t _flags_save_string = ndr->flags;
16600                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16601                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
16602                         ndr->flags = _flags_save_string;
16603                 }
16604                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16605                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16606                 {
16607                         uint32_t _flags_save_string = ndr->flags;
16608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16609                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
16610                         ndr->flags = _flags_save_string;
16611                 }
16612                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
16613                 {
16614                         uint32_t _flags_save_string = ndr->flags;
16615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16616                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
16617                         ndr->flags = _flags_save_string;
16618                 }
16619                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
16620                 {
16621                         uint32_t _flags_save_string = ndr->flags;
16622                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16623                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
16624                         ndr->flags = _flags_save_string;
16625                 }
16626                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lang_id));
16627                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unused));
16628                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16629         }
16630         if (ndr_flags & NDR_BUFFERS) {
16631                 {
16632                         uint32_t _flags_save_string = ndr->flags;
16633                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16634                         if (r->form_name) {
16635                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->form_name));
16636                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
16637                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->form_name));
16638                         }
16639                         ndr->flags = _flags_save_string;
16640                 }
16641                 {
16642                         uint32_t _flags_save_string = ndr->flags;
16643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16644                         if (r->keyword) {
16645                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->keyword));
16646                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
16647                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->keyword));
16648                         }
16649                         ndr->flags = _flags_save_string;
16650                 }
16651                 {
16652                         uint32_t _flags_save_string = ndr->flags;
16653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16654                         if (r->mui_dll) {
16655                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->mui_dll));
16656                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
16657                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->mui_dll));
16658                         }
16659                         ndr->flags = _flags_save_string;
16660                 }
16661                 {
16662                         uint32_t _flags_save_string = ndr->flags;
16663                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16664                         if (r->display_name) {
16665                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->display_name));
16666                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
16667                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->display_name));
16668                         }
16669                         ndr->flags = _flags_save_string;
16670                 }
16671         }
16672         return NDR_ERR_SUCCESS;
16673 }
16674
16675 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
16676 {
16677         uint32_t _ptr_form_name;
16678         TALLOC_CTX *_mem_save_form_name_0;
16679         uint32_t _ptr_keyword;
16680         TALLOC_CTX *_mem_save_keyword_0;
16681         uint32_t _ptr_mui_dll;
16682         TALLOC_CTX *_mem_save_mui_dll_0;
16683         uint32_t _ptr_display_name;
16684         TALLOC_CTX *_mem_save_display_name_0;
16685         if (ndr_flags & NDR_SCALARS) {
16686                 NDR_CHECK(ndr_pull_align(ndr, 5));
16687                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16688                 {
16689                         uint32_t _flags_save_string = ndr->flags;
16690                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16691                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16692                         if (_ptr_form_name) {
16693                                 NDR_PULL_ALLOC(ndr, r->form_name);
16694                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
16695                         } else {
16696                                 r->form_name = NULL;
16697                         }
16698                         ndr->flags = _flags_save_string;
16699                 }
16700                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16701                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16702                 {
16703                         uint32_t _flags_save_string = ndr->flags;
16704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16705                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16706                         if (_ptr_keyword) {
16707                                 NDR_PULL_ALLOC(ndr, r->keyword);
16708                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
16709                         } else {
16710                                 r->keyword = NULL;
16711                         }
16712                         ndr->flags = _flags_save_string;
16713                 }
16714                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16715                 {
16716                         uint32_t _flags_save_string = ndr->flags;
16717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16718                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16719                         if (_ptr_mui_dll) {
16720                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
16721                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
16722                         } else {
16723                                 r->mui_dll = NULL;
16724                         }
16725                         ndr->flags = _flags_save_string;
16726                 }
16727                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16728                 {
16729                         uint32_t _flags_save_string = ndr->flags;
16730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16731                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16732                         if (_ptr_display_name) {
16733                                 NDR_PULL_ALLOC(ndr, r->display_name);
16734                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
16735                         } else {
16736                                 r->display_name = NULL;
16737                         }
16738                         ndr->flags = _flags_save_string;
16739                 }
16740                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lang_id));
16741                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unused));
16742                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16743         }
16744         if (ndr_flags & NDR_BUFFERS) {
16745                 {
16746                         uint32_t _flags_save_string = ndr->flags;
16747                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16748                         if (r->form_name) {
16749                                 uint32_t _relative_save_offset;
16750                                 _relative_save_offset = ndr->offset;
16751                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
16752                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16753                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16754                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
16755                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16756                                 if (ndr->offset > ndr->relative_highest_offset) {
16757                                         ndr->relative_highest_offset = ndr->offset;
16758                                 }
16759                                 ndr->offset = _relative_save_offset;
16760                         }
16761                         ndr->flags = _flags_save_string;
16762                 }
16763                 {
16764                         uint32_t _flags_save_string = ndr->flags;
16765                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16766                         if (r->keyword) {
16767                                 uint32_t _relative_save_offset;
16768                                 _relative_save_offset = ndr->offset;
16769                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
16770                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16771                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16772                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
16773                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16774                                 if (ndr->offset > ndr->relative_highest_offset) {
16775                                         ndr->relative_highest_offset = ndr->offset;
16776                                 }
16777                                 ndr->offset = _relative_save_offset;
16778                         }
16779                         ndr->flags = _flags_save_string;
16780                 }
16781                 {
16782                         uint32_t _flags_save_string = ndr->flags;
16783                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16784                         if (r->mui_dll) {
16785                                 uint32_t _relative_save_offset;
16786                                 _relative_save_offset = ndr->offset;
16787                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
16788                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16789                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16790                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
16791                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16792                                 if (ndr->offset > ndr->relative_highest_offset) {
16793                                         ndr->relative_highest_offset = ndr->offset;
16794                                 }
16795                                 ndr->offset = _relative_save_offset;
16796                         }
16797                         ndr->flags = _flags_save_string;
16798                 }
16799                 {
16800                         uint32_t _flags_save_string = ndr->flags;
16801                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16802                         if (r->display_name) {
16803                                 uint32_t _relative_save_offset;
16804                                 _relative_save_offset = ndr->offset;
16805                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
16806                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16807                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16808                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
16809                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16810                                 if (ndr->offset > ndr->relative_highest_offset) {
16811                                         ndr->relative_highest_offset = ndr->offset;
16812                                 }
16813                                 ndr->offset = _relative_save_offset;
16814                         }
16815                         ndr->flags = _flags_save_string;
16816                 }
16817         }
16818         return NDR_ERR_SUCCESS;
16819 }
16820
16821 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
16822 {
16823         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
16824         ndr->depth++;
16825         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16826         ndr_print_ptr(ndr, "form_name", r->form_name);
16827         ndr->depth++;
16828         if (r->form_name) {
16829                 ndr_print_string(ndr, "form_name", r->form_name);
16830         }
16831         ndr->depth--;
16832         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16833         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16834         ndr_print_ptr(ndr, "keyword", r->keyword);
16835         ndr->depth++;
16836         if (r->keyword) {
16837                 ndr_print_string(ndr, "keyword", r->keyword);
16838         }
16839         ndr->depth--;
16840         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16841         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16842         ndr->depth++;
16843         if (r->mui_dll) {
16844                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16845         }
16846         ndr->depth--;
16847         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16848         ndr_print_ptr(ndr, "display_name", r->display_name);
16849         ndr->depth++;
16850         if (r->display_name) {
16851                 ndr_print_string(ndr, "display_name", r->display_name);
16852         }
16853         ndr->depth--;
16854         ndr_print_uint16(ndr, "lang_id", r->lang_id);
16855         ndr_print_uint16(ndr, "unused", r->unused);
16856         ndr->depth--;
16857 }
16858
16859 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16860 {
16861         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
16862 }
16863
16864 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
16865 {
16866         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16867         {
16868                 uint32_t _flags_save_UNION = ndr->flags;
16869                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
16870                 if (ndr_flags & NDR_SCALARS) {
16871                         int level = ndr_push_get_switch_value(ndr, r);
16872                         NDR_CHECK(ndr_push_union_align(ndr, 5));
16873                         switch (level) {
16874                                 case 1: {
16875                                         NDR_CHECK(ndr_push_align(ndr, 5));
16876                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16877                                         NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16878                                 break; }
16879
16880                                 case 2: {
16881                                         NDR_CHECK(ndr_push_align(ndr, 5));
16882                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16883                                         NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16884                                 break; }
16885
16886                                 default: {
16887                                 break; }
16888
16889                         }
16890                 }
16891                 if (ndr_flags & NDR_BUFFERS) {
16892                         int level = ndr_push_get_switch_value(ndr, r);
16893                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16894                         switch (level) {
16895                                 case 1:
16896                                         NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16897                                 break;
16898
16899                                 case 2:
16900                                         NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16901                                 break;
16902
16903                                 default:
16904                                 break;
16905
16906                         }
16907                 }
16908                 ndr->flags = _flags_save_UNION;
16909         }
16910         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16911         return NDR_ERR_SUCCESS;
16912 }
16913
16914 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
16915 {
16916         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16917         int level;
16918         {
16919                 uint32_t _flags_save_UNION = ndr->flags;
16920                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
16921                 level = ndr_pull_get_switch_value(ndr, r);
16922                 if (ndr_flags & NDR_SCALARS) {
16923                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
16924                         switch (level) {
16925                                 case 1: {
16926                                         NDR_CHECK(ndr_pull_align(ndr, 5));
16927                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16928                                         NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16929                                 break; }
16930
16931                                 case 2: {
16932                                         NDR_CHECK(ndr_pull_align(ndr, 5));
16933                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16934                                         NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16935                                 break; }
16936
16937                                 default: {
16938                                 break; }
16939
16940                         }
16941                 }
16942                 if (ndr_flags & NDR_BUFFERS) {
16943                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16944                         switch (level) {
16945                                 case 1:
16946                                         NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16947                                 break;
16948
16949                                 case 2:
16950                                         NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16951                                 break;
16952
16953                                 default:
16954                                 break;
16955
16956                         }
16957                 }
16958                 ndr->flags = _flags_save_UNION;
16959         }
16960         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16961         return NDR_ERR_SUCCESS;
16962 }
16963
16964 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
16965 {
16966         int level;
16967         {
16968                 uint32_t _flags_save_UNION = ndr->flags;
16969                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
16970                 level = ndr_print_get_switch_value(ndr, r);
16971                 ndr_print_union(ndr, name, level, "spoolss_FormInfo");
16972                 switch (level) {
16973                         case 1:
16974                                 ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
16975                         break;
16976
16977                         case 2:
16978                                 ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
16979                         break;
16980
16981                         default:
16982                         break;
16983
16984                 }
16985                 ndr->flags = _flags_save_UNION;
16986         }
16987 }
16988
16989 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
16990 {
16991         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
16992         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
16993 }
16994
16995 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
16996 {
16997         if (ndr_flags & NDR_SCALARS) {
16998                 NDR_CHECK(ndr_push_align(ndr, 5));
16999                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
17000                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
17001                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
17002                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
17003                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17004         }
17005         if (ndr_flags & NDR_BUFFERS) {
17006                 if (r->form_name) {
17007                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
17008                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17009                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
17010                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17011                 }
17012         }
17013         return NDR_ERR_SUCCESS;
17014 }
17015
17016 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
17017 {
17018         uint32_t _ptr_form_name;
17019         TALLOC_CTX *_mem_save_form_name_0;
17020         if (ndr_flags & NDR_SCALARS) {
17021                 NDR_CHECK(ndr_pull_align(ndr, 5));
17022                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
17023                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
17024                 if (_ptr_form_name) {
17025                         NDR_PULL_ALLOC(ndr, r->form_name);
17026                 } else {
17027                         r->form_name = NULL;
17028                 }
17029                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
17030                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
17031                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17032         }
17033         if (ndr_flags & NDR_BUFFERS) {
17034                 if (r->form_name) {
17035                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17036                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
17037                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
17038                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
17039                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
17040                                 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));
17041                         }
17042                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
17043                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
17044                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
17045                 }
17046         }
17047         return NDR_ERR_SUCCESS;
17048 }
17049
17050 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
17051 {
17052         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
17053         ndr->depth++;
17054         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
17055         ndr_print_ptr(ndr, "form_name", r->form_name);
17056         ndr->depth++;
17057         if (r->form_name) {
17058                 ndr_print_string(ndr, "form_name", r->form_name);
17059         }
17060         ndr->depth--;
17061         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
17062         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
17063         ndr->depth--;
17064 }
17065
17066 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
17067 {
17068         if (ndr_flags & NDR_SCALARS) {
17069                 NDR_CHECK(ndr_push_align(ndr, 5));
17070                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
17071                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
17072                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
17073                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
17074                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
17075                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
17076                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
17077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
17078                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
17079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
17080                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17081         }
17082         if (ndr_flags & NDR_BUFFERS) {
17083                 if (r->form_name) {
17084                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
17085                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17086                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
17087                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17088                 }
17089                 if (r->keyword) {
17090                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
17091                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17092                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
17093                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
17094                 }
17095                 if (r->mui_dll) {
17096                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
17097                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17098                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
17099                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17100                 }
17101                 if (r->display_name) {
17102                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
17103                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17104                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
17105                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17106                 }
17107         }
17108         return NDR_ERR_SUCCESS;
17109 }
17110
17111 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
17112 {
17113         uint32_t _ptr_form_name;
17114         TALLOC_CTX *_mem_save_form_name_0;
17115         uint32_t _ptr_keyword;
17116         TALLOC_CTX *_mem_save_keyword_0;
17117         uint32_t _ptr_mui_dll;
17118         TALLOC_CTX *_mem_save_mui_dll_0;
17119         uint32_t _ptr_display_name;
17120         TALLOC_CTX *_mem_save_display_name_0;
17121         if (ndr_flags & NDR_SCALARS) {
17122                 NDR_CHECK(ndr_pull_align(ndr, 5));
17123                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
17124                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
17125                 if (_ptr_form_name) {
17126                         NDR_PULL_ALLOC(ndr, r->form_name);
17127                 } else {
17128                         r->form_name = NULL;
17129                 }
17130                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
17131                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
17132                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
17133                 if (_ptr_keyword) {
17134                         NDR_PULL_ALLOC(ndr, r->keyword);
17135                 } else {
17136                         r->keyword = NULL;
17137                 }
17138                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
17139                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
17140                 if (_ptr_mui_dll) {
17141                         NDR_PULL_ALLOC(ndr, r->mui_dll);
17142                 } else {
17143                         r->mui_dll = NULL;
17144                 }
17145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
17146                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
17147                 if (_ptr_display_name) {
17148                         NDR_PULL_ALLOC(ndr, r->display_name);
17149                 } else {
17150                         r->display_name = NULL;
17151                 }
17152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
17153                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17154         }
17155         if (ndr_flags & NDR_BUFFERS) {
17156                 if (r->form_name) {
17157                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17158                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
17159                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
17160                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
17161                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
17162                                 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));
17163                         }
17164                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
17165                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
17166                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
17167                 }
17168                 if (r->keyword) {
17169                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
17170                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
17171                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
17172                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
17173                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
17174                                 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));
17175                         }
17176                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
17177                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
17178                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
17179                 }
17180                 if (r->mui_dll) {
17181                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
17182                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
17183                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
17184                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
17185                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
17186                                 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));
17187                         }
17188                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
17189                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
17190                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
17191                 }
17192                 if (r->display_name) {
17193                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17194                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
17195                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
17196                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
17197                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
17198                                 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));
17199                         }
17200                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
17201                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
17202                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
17203                 }
17204         }
17205         return NDR_ERR_SUCCESS;
17206 }
17207
17208 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
17209 {
17210         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
17211         ndr->depth++;
17212         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
17213         ndr_print_ptr(ndr, "form_name", r->form_name);
17214         ndr->depth++;
17215         if (r->form_name) {
17216                 ndr_print_string(ndr, "form_name", r->form_name);
17217         }
17218         ndr->depth--;
17219         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
17220         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
17221         ndr_print_ptr(ndr, "keyword", r->keyword);
17222         ndr->depth++;
17223         if (r->keyword) {
17224                 ndr_print_string(ndr, "keyword", r->keyword);
17225         }
17226         ndr->depth--;
17227         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
17228         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
17229         ndr->depth++;
17230         if (r->mui_dll) {
17231                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
17232         }
17233         ndr->depth--;
17234         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
17235         ndr_print_ptr(ndr, "display_name", r->display_name);
17236         ndr->depth++;
17237         if (r->display_name) {
17238                 ndr_print_string(ndr, "display_name", r->display_name);
17239         }
17240         ndr->depth--;
17241         ndr_print_uint32(ndr, "lang_id", r->lang_id);
17242         ndr->depth--;
17243 }
17244
17245 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
17246 {
17247         if (ndr_flags & NDR_SCALARS) {
17248                 int level = ndr_push_get_switch_value(ndr, r);
17249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17250                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17251                 switch (level) {
17252                         case 1: {
17253                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
17254                         break; }
17255
17256                         case 2: {
17257                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
17258                         break; }
17259
17260                         default:
17261                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
17262                 }
17263         }
17264         if (ndr_flags & NDR_BUFFERS) {
17265                 int level = ndr_push_get_switch_value(ndr, r);
17266                 switch (level) {
17267                         case 1:
17268                                 if (r->info1) {
17269                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
17270                                 }
17271                         break;
17272
17273                         case 2:
17274                                 if (r->info2) {
17275                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
17276                                 }
17277                         break;
17278
17279                         default:
17280                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
17281                 }
17282         }
17283         return NDR_ERR_SUCCESS;
17284 }
17285
17286 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
17287 {
17288         int level;
17289         uint32_t _level;
17290         TALLOC_CTX *_mem_save_info1_0;
17291         TALLOC_CTX *_mem_save_info2_0;
17292         level = ndr_pull_get_switch_value(ndr, r);
17293         if (ndr_flags & NDR_SCALARS) {
17294                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17295                 if (_level != level) {
17296                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
17297                 }
17298                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17299                 switch (level) {
17300                         case 1: {
17301                                 uint32_t _ptr_info1;
17302                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
17303                                 if (_ptr_info1) {
17304                                         NDR_PULL_ALLOC(ndr, r->info1);
17305                                 } else {
17306                                         r->info1 = NULL;
17307                                 }
17308                         break; }
17309
17310                         case 2: {
17311                                 uint32_t _ptr_info2;
17312                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
17313                                 if (_ptr_info2) {
17314                                         NDR_PULL_ALLOC(ndr, r->info2);
17315                                 } else {
17316                                         r->info2 = NULL;
17317                                 }
17318                         break; }
17319
17320                         default:
17321                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
17322                 }
17323         }
17324         if (ndr_flags & NDR_BUFFERS) {
17325                 switch (level) {
17326                         case 1:
17327                                 if (r->info1) {
17328                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
17329                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
17330                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
17331                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
17332                                 }
17333                         break;
17334
17335                         case 2:
17336                                 if (r->info2) {
17337                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
17338                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
17339                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
17340                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
17341                                 }
17342                         break;
17343
17344                         default:
17345                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
17346                 }
17347         }
17348         return NDR_ERR_SUCCESS;
17349 }
17350
17351 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
17352 {
17353         int level;
17354         level = ndr_print_get_switch_value(ndr, r);
17355         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
17356         switch (level) {
17357                 case 1:
17358                         ndr_print_ptr(ndr, "info1", r->info1);
17359                         ndr->depth++;
17360                         if (r->info1) {
17361                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
17362                         }
17363                         ndr->depth--;
17364                 break;
17365
17366                 case 2:
17367                         ndr_print_ptr(ndr, "info2", r->info2);
17368                         ndr->depth++;
17369                         if (r->info2) {
17370                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
17371                         }
17372                         ndr->depth--;
17373                 break;
17374
17375                 default:
17376                         ndr_print_bad_level(ndr, name, level);
17377         }
17378 }
17379
17380 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
17381 {
17382         if (ndr_flags & NDR_SCALARS) {
17383                 NDR_CHECK(ndr_push_align(ndr, 5));
17384                 {
17385                         uint32_t _flags_save_string = ndr->flags;
17386                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17387                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17388                         ndr->flags = _flags_save_string;
17389                 }
17390                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17391         }
17392         if (ndr_flags & NDR_BUFFERS) {
17393                 {
17394                         uint32_t _flags_save_string = ndr->flags;
17395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17396                         if (r->port_name) {
17397                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
17398                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17399                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
17400                         }
17401                         ndr->flags = _flags_save_string;
17402                 }
17403         }
17404         return NDR_ERR_SUCCESS;
17405 }
17406
17407 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
17408 {
17409         uint32_t _ptr_port_name;
17410         TALLOC_CTX *_mem_save_port_name_0;
17411         if (ndr_flags & NDR_SCALARS) {
17412                 NDR_CHECK(ndr_pull_align(ndr, 5));
17413                 {
17414                         uint32_t _flags_save_string = ndr->flags;
17415                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17416                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17417                         if (_ptr_port_name) {
17418                                 NDR_PULL_ALLOC(ndr, r->port_name);
17419                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17420                         } else {
17421                                 r->port_name = NULL;
17422                         }
17423                         ndr->flags = _flags_save_string;
17424                 }
17425                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17426         }
17427         if (ndr_flags & NDR_BUFFERS) {
17428                 {
17429                         uint32_t _flags_save_string = ndr->flags;
17430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17431                         if (r->port_name) {
17432                                 uint32_t _relative_save_offset;
17433                                 _relative_save_offset = ndr->offset;
17434                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17435                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17436                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17437                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17438                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17439                                 if (ndr->offset > ndr->relative_highest_offset) {
17440                                         ndr->relative_highest_offset = ndr->offset;
17441                                 }
17442                                 ndr->offset = _relative_save_offset;
17443                         }
17444                         ndr->flags = _flags_save_string;
17445                 }
17446         }
17447         return NDR_ERR_SUCCESS;
17448 }
17449
17450 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
17451 {
17452         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
17453         ndr->depth++;
17454         ndr_print_ptr(ndr, "port_name", r->port_name);
17455         ndr->depth++;
17456         if (r->port_name) {
17457                 ndr_print_string(ndr, "port_name", r->port_name);
17458         }
17459         ndr->depth--;
17460         ndr->depth--;
17461 }
17462
17463 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17464 {
17465         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
17466 }
17467
17468 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17469 {
17470         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17471         return NDR_ERR_SUCCESS;
17472 }
17473
17474 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17475 {
17476         uint32_t v;
17477         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17478         *r = v;
17479         return NDR_ERR_SUCCESS;
17480 }
17481
17482 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
17483 {
17484         ndr_print_uint32(ndr, name, r);
17485         ndr->depth++;
17486         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
17487         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
17488         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
17489         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
17490         ndr->depth--;
17491 }
17492
17493 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
17494 {
17495         if (ndr_flags & NDR_SCALARS) {
17496                 NDR_CHECK(ndr_push_align(ndr, 5));
17497                 {
17498                         uint32_t _flags_save_string = ndr->flags;
17499                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17500                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17501                         ndr->flags = _flags_save_string;
17502                 }
17503                 {
17504                         uint32_t _flags_save_string = ndr->flags;
17505                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17506                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17507                         ndr->flags = _flags_save_string;
17508                 }
17509                 {
17510                         uint32_t _flags_save_string = ndr->flags;
17511                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17512                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
17513                         ndr->flags = _flags_save_string;
17514                 }
17515                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
17516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
17517                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17518         }
17519         if (ndr_flags & NDR_BUFFERS) {
17520                 {
17521                         uint32_t _flags_save_string = ndr->flags;
17522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17523                         if (r->port_name) {
17524                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
17525                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17526                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
17527                         }
17528                         ndr->flags = _flags_save_string;
17529                 }
17530                 {
17531                         uint32_t _flags_save_string = ndr->flags;
17532                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17533                         if (r->monitor_name) {
17534                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
17535                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17536                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
17537                         }
17538                         ndr->flags = _flags_save_string;
17539                 }
17540                 {
17541                         uint32_t _flags_save_string = ndr->flags;
17542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17543                         if (r->description) {
17544                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->description));
17545                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
17546                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->description));
17547                         }
17548                         ndr->flags = _flags_save_string;
17549                 }
17550         }
17551         return NDR_ERR_SUCCESS;
17552 }
17553
17554 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
17555 {
17556         uint32_t _ptr_port_name;
17557         TALLOC_CTX *_mem_save_port_name_0;
17558         uint32_t _ptr_monitor_name;
17559         TALLOC_CTX *_mem_save_monitor_name_0;
17560         uint32_t _ptr_description;
17561         TALLOC_CTX *_mem_save_description_0;
17562         if (ndr_flags & NDR_SCALARS) {
17563                 NDR_CHECK(ndr_pull_align(ndr, 5));
17564                 {
17565                         uint32_t _flags_save_string = ndr->flags;
17566                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17567                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17568                         if (_ptr_port_name) {
17569                                 NDR_PULL_ALLOC(ndr, r->port_name);
17570                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17571                         } else {
17572                                 r->port_name = NULL;
17573                         }
17574                         ndr->flags = _flags_save_string;
17575                 }
17576                 {
17577                         uint32_t _flags_save_string = ndr->flags;
17578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17579                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17580                         if (_ptr_monitor_name) {
17581                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17582                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17583                         } else {
17584                                 r->monitor_name = NULL;
17585                         }
17586                         ndr->flags = _flags_save_string;
17587                 }
17588                 {
17589                         uint32_t _flags_save_string = ndr->flags;
17590                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17591                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
17592                         if (_ptr_description) {
17593                                 NDR_PULL_ALLOC(ndr, r->description);
17594                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
17595                         } else {
17596                                 r->description = NULL;
17597                         }
17598                         ndr->flags = _flags_save_string;
17599                 }
17600                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
17601                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
17602                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17603         }
17604         if (ndr_flags & NDR_BUFFERS) {
17605                 {
17606                         uint32_t _flags_save_string = ndr->flags;
17607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17608                         if (r->port_name) {
17609                                 uint32_t _relative_save_offset;
17610                                 _relative_save_offset = ndr->offset;
17611                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17612                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17613                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17614                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17615                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17616                                 if (ndr->offset > ndr->relative_highest_offset) {
17617                                         ndr->relative_highest_offset = ndr->offset;
17618                                 }
17619                                 ndr->offset = _relative_save_offset;
17620                         }
17621                         ndr->flags = _flags_save_string;
17622                 }
17623                 {
17624                         uint32_t _flags_save_string = ndr->flags;
17625                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17626                         if (r->monitor_name) {
17627                                 uint32_t _relative_save_offset;
17628                                 _relative_save_offset = ndr->offset;
17629                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17630                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17631                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17632                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17633                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17634                                 if (ndr->offset > ndr->relative_highest_offset) {
17635                                         ndr->relative_highest_offset = ndr->offset;
17636                                 }
17637                                 ndr->offset = _relative_save_offset;
17638                         }
17639                         ndr->flags = _flags_save_string;
17640                 }
17641                 {
17642                         uint32_t _flags_save_string = ndr->flags;
17643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17644                         if (r->description) {
17645                                 uint32_t _relative_save_offset;
17646                                 _relative_save_offset = ndr->offset;
17647                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
17648                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
17649                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
17650                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
17651                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
17652                                 if (ndr->offset > ndr->relative_highest_offset) {
17653                                         ndr->relative_highest_offset = ndr->offset;
17654                                 }
17655                                 ndr->offset = _relative_save_offset;
17656                         }
17657                         ndr->flags = _flags_save_string;
17658                 }
17659         }
17660         return NDR_ERR_SUCCESS;
17661 }
17662
17663 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
17664 {
17665         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
17666         ndr->depth++;
17667         ndr_print_ptr(ndr, "port_name", r->port_name);
17668         ndr->depth++;
17669         if (r->port_name) {
17670                 ndr_print_string(ndr, "port_name", r->port_name);
17671         }
17672         ndr->depth--;
17673         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17674         ndr->depth++;
17675         if (r->monitor_name) {
17676                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17677         }
17678         ndr->depth--;
17679         ndr_print_ptr(ndr, "description", r->description);
17680         ndr->depth++;
17681         if (r->description) {
17682                 ndr_print_string(ndr, "description", r->description);
17683         }
17684         ndr->depth--;
17685         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
17686         ndr_print_uint32(ndr, "reserved", r->reserved);
17687         ndr->depth--;
17688 }
17689
17690 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17691 {
17692         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
17693 }
17694
17695 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
17696 {
17697         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17698         return NDR_ERR_SUCCESS;
17699 }
17700
17701 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
17702 {
17703         uint32_t v;
17704         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17705         *r = v;
17706         return NDR_ERR_SUCCESS;
17707 }
17708
17709 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
17710 {
17711         const char *val = NULL;
17712
17713         switch (r) {
17714                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
17715                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
17716                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
17717                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
17718                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
17719                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
17720                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
17721                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
17722                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
17723                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
17724                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
17725                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
17726                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
17727         }
17728         ndr_print_enum(ndr, name, "ENUM", val, r);
17729 }
17730
17731 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
17732 {
17733         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17734         return NDR_ERR_SUCCESS;
17735 }
17736
17737 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
17738 {
17739         uint32_t v;
17740         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17741         *r = v;
17742         return NDR_ERR_SUCCESS;
17743 }
17744
17745 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
17746 {
17747         const char *val = NULL;
17748
17749         switch (r) {
17750                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
17751                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
17752                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
17753         }
17754         ndr_print_enum(ndr, name, "ENUM", val, r);
17755 }
17756
17757 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
17758 {
17759         if (ndr_flags & NDR_SCALARS) {
17760                 NDR_CHECK(ndr_push_align(ndr, 5));
17761                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
17762                 {
17763                         uint32_t _flags_save_string = ndr->flags;
17764                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17765                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
17766                         ndr->flags = _flags_save_string;
17767                 }
17768                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
17769                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17770         }
17771         if (ndr_flags & NDR_BUFFERS) {
17772                 {
17773                         uint32_t _flags_save_string = ndr->flags;
17774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17775                         if (r->status_string) {
17776                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->status_string));
17777                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
17778                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->status_string));
17779                         }
17780                         ndr->flags = _flags_save_string;
17781                 }
17782         }
17783         return NDR_ERR_SUCCESS;
17784 }
17785
17786 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
17787 {
17788         uint32_t _ptr_status_string;
17789         TALLOC_CTX *_mem_save_status_string_0;
17790         if (ndr_flags & NDR_SCALARS) {
17791                 NDR_CHECK(ndr_pull_align(ndr, 5));
17792                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
17793                 {
17794                         uint32_t _flags_save_string = ndr->flags;
17795                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17796                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
17797                         if (_ptr_status_string) {
17798                                 NDR_PULL_ALLOC(ndr, r->status_string);
17799                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
17800                         } else {
17801                                 r->status_string = NULL;
17802                         }
17803                         ndr->flags = _flags_save_string;
17804                 }
17805                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
17806                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17807         }
17808         if (ndr_flags & NDR_BUFFERS) {
17809                 {
17810                         uint32_t _flags_save_string = ndr->flags;
17811                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17812                         if (r->status_string) {
17813                                 uint32_t _relative_save_offset;
17814                                 _relative_save_offset = ndr->offset;
17815                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
17816                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17817                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
17818                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
17819                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
17820                                 if (ndr->offset > ndr->relative_highest_offset) {
17821                                         ndr->relative_highest_offset = ndr->offset;
17822                                 }
17823                                 ndr->offset = _relative_save_offset;
17824                         }
17825                         ndr->flags = _flags_save_string;
17826                 }
17827         }
17828         return NDR_ERR_SUCCESS;
17829 }
17830
17831 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
17832 {
17833         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
17834         ndr->depth++;
17835         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
17836         ndr_print_ptr(ndr, "status_string", r->status_string);
17837         ndr->depth++;
17838         if (r->status_string) {
17839                 ndr_print_string(ndr, "status_string", r->status_string);
17840         }
17841         ndr->depth--;
17842         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
17843         ndr->depth--;
17844 }
17845
17846 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
17847 {
17848         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
17849 }
17850
17851 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
17852 {
17853         if (ndr_flags & NDR_SCALARS) {
17854                 NDR_CHECK(ndr_push_align(ndr, 5));
17855                 {
17856                         uint32_t _flags_save_string = ndr->flags;
17857                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17858                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17859                         ndr->flags = _flags_save_string;
17860                 }
17861                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
17862                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17863         }
17864         if (ndr_flags & NDR_BUFFERS) {
17865                 {
17866                         uint32_t _flags_save_string = ndr->flags;
17867                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17868                         if (r->port_name) {
17869                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
17870                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17871                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
17872                         }
17873                         ndr->flags = _flags_save_string;
17874                 }
17875         }
17876         return NDR_ERR_SUCCESS;
17877 }
17878
17879 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
17880 {
17881         uint32_t _ptr_port_name;
17882         TALLOC_CTX *_mem_save_port_name_0;
17883         if (ndr_flags & NDR_SCALARS) {
17884                 NDR_CHECK(ndr_pull_align(ndr, 5));
17885                 {
17886                         uint32_t _flags_save_string = ndr->flags;
17887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17888                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17889                         if (_ptr_port_name) {
17890                                 NDR_PULL_ALLOC(ndr, r->port_name);
17891                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17892                         } else {
17893                                 r->port_name = NULL;
17894                         }
17895                         ndr->flags = _flags_save_string;
17896                 }
17897                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
17898                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17899         }
17900         if (ndr_flags & NDR_BUFFERS) {
17901                 {
17902                         uint32_t _flags_save_string = ndr->flags;
17903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17904                         if (r->port_name) {
17905                                 uint32_t _relative_save_offset;
17906                                 _relative_save_offset = ndr->offset;
17907                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17908                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17909                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17910                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17911                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17912                                 if (ndr->offset > ndr->relative_highest_offset) {
17913                                         ndr->relative_highest_offset = ndr->offset;
17914                                 }
17915                                 ndr->offset = _relative_save_offset;
17916                         }
17917                         ndr->flags = _flags_save_string;
17918                 }
17919         }
17920         return NDR_ERR_SUCCESS;
17921 }
17922
17923 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
17924 {
17925         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
17926         ndr->depth++;
17927         ndr_print_ptr(ndr, "port_name", r->port_name);
17928         ndr->depth++;
17929         if (r->port_name) {
17930                 ndr_print_string(ndr, "port_name", r->port_name);
17931         }
17932         ndr->depth--;
17933         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
17934         ndr->depth--;
17935 }
17936
17937 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
17938 {
17939         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
17940 }
17941
17942 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
17943 {
17944         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17945         {
17946                 uint32_t _flags_save_UNION = ndr->flags;
17947                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17948                 if (ndr_flags & NDR_SCALARS) {
17949                         int level = ndr_push_get_switch_value(ndr, r);
17950                         NDR_CHECK(ndr_push_union_align(ndr, 5));
17951                         switch (level) {
17952                                 case 1: {
17953                                         NDR_CHECK(ndr_push_align(ndr, 5));
17954                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17955                                         NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
17956                                 break; }
17957
17958                                 case 2: {
17959                                         NDR_CHECK(ndr_push_align(ndr, 5));
17960                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17961                                         NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
17962                                 break; }
17963
17964                                 case 3: {
17965                                         NDR_CHECK(ndr_push_align(ndr, 5));
17966                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17967                                         NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
17968                                 break; }
17969
17970                                 case 0xff: {
17971                                         NDR_CHECK(ndr_push_align(ndr, 5));
17972                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17973                                         NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
17974                                 break; }
17975
17976                                 default: {
17977                                 break; }
17978
17979                         }
17980                 }
17981                 if (ndr_flags & NDR_BUFFERS) {
17982                         int level = ndr_push_get_switch_value(ndr, r);
17983                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17984                         switch (level) {
17985                                 case 1:
17986                                         NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
17987                                 break;
17988
17989                                 case 2:
17990                                         NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
17991                                 break;
17992
17993                                 case 3:
17994                                         NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
17995                                 break;
17996
17997                                 case 0xff:
17998                                         NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17999                                 break;
18000
18001                                 default:
18002                                 break;
18003
18004                         }
18005                 }
18006                 ndr->flags = _flags_save_UNION;
18007         }
18008         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18009         return NDR_ERR_SUCCESS;
18010 }
18011
18012 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
18013 {
18014         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18015         int level;
18016         {
18017                 uint32_t _flags_save_UNION = ndr->flags;
18018                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18019                 level = ndr_pull_get_switch_value(ndr, r);
18020                 if (ndr_flags & NDR_SCALARS) {
18021                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
18022                         switch (level) {
18023                                 case 1: {
18024                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18025                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18026                                         NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
18027                                 break; }
18028
18029                                 case 2: {
18030                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18031                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18032                                         NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
18033                                 break; }
18034
18035                                 case 3: {
18036                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18037                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18038                                         NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
18039                                 break; }
18040
18041                                 case 0xff: {
18042                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18043                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18044                                         NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
18045                                 break; }
18046
18047                                 default: {
18048                                 break; }
18049
18050                         }
18051                 }
18052                 if (ndr_flags & NDR_BUFFERS) {
18053                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18054                         switch (level) {
18055                                 case 1:
18056                                         NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
18057                                 break;
18058
18059                                 case 2:
18060                                         NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
18061                                 break;
18062
18063                                 case 3:
18064                                         NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
18065                                 break;
18066
18067                                 case 0xff:
18068                                         NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
18069                                 break;
18070
18071                                 default:
18072                                 break;
18073
18074                         }
18075                 }
18076                 ndr->flags = _flags_save_UNION;
18077         }
18078         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18079         return NDR_ERR_SUCCESS;
18080 }
18081
18082 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
18083 {
18084         int level;
18085         {
18086                 uint32_t _flags_save_UNION = ndr->flags;
18087                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18088                 level = ndr_print_get_switch_value(ndr, r);
18089                 ndr_print_union(ndr, name, level, "spoolss_PortInfo");
18090                 switch (level) {
18091                         case 1:
18092                                 ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
18093                         break;
18094
18095                         case 2:
18096                                 ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
18097                         break;
18098
18099                         case 3:
18100                                 ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
18101                         break;
18102
18103                         case 0xff:
18104                                 ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
18105                         break;
18106
18107                         default:
18108                         break;
18109
18110                 }
18111                 ndr->flags = _flags_save_UNION;
18112         }
18113 }
18114
18115 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
18116 {
18117         if (ndr_flags & NDR_SCALARS) {
18118                 NDR_CHECK(ndr_push_align(ndr, 5));
18119                 {
18120                         uint32_t _flags_save_string = ndr->flags;
18121                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18122                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
18123                         ndr->flags = _flags_save_string;
18124                 }
18125                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18126         }
18127         if (ndr_flags & NDR_BUFFERS) {
18128                 {
18129                         uint32_t _flags_save_string = ndr->flags;
18130                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18131                         if (r->monitor_name) {
18132                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
18133                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
18134                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
18135                         }
18136                         ndr->flags = _flags_save_string;
18137                 }
18138         }
18139         return NDR_ERR_SUCCESS;
18140 }
18141
18142 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
18143 {
18144         uint32_t _ptr_monitor_name;
18145         TALLOC_CTX *_mem_save_monitor_name_0;
18146         if (ndr_flags & NDR_SCALARS) {
18147                 NDR_CHECK(ndr_pull_align(ndr, 5));
18148                 {
18149                         uint32_t _flags_save_string = ndr->flags;
18150                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18151                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
18152                         if (_ptr_monitor_name) {
18153                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
18154                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
18155                         } else {
18156                                 r->monitor_name = NULL;
18157                         }
18158                         ndr->flags = _flags_save_string;
18159                 }
18160                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18161         }
18162         if (ndr_flags & NDR_BUFFERS) {
18163                 {
18164                         uint32_t _flags_save_string = ndr->flags;
18165                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18166                         if (r->monitor_name) {
18167                                 uint32_t _relative_save_offset;
18168                                 _relative_save_offset = ndr->offset;
18169                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
18170                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18171                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
18172                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
18173                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
18174                                 if (ndr->offset > ndr->relative_highest_offset) {
18175                                         ndr->relative_highest_offset = ndr->offset;
18176                                 }
18177                                 ndr->offset = _relative_save_offset;
18178                         }
18179                         ndr->flags = _flags_save_string;
18180                 }
18181         }
18182         return NDR_ERR_SUCCESS;
18183 }
18184
18185 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
18186 {
18187         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
18188         ndr->depth++;
18189         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
18190         ndr->depth++;
18191         if (r->monitor_name) {
18192                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
18193         }
18194         ndr->depth--;
18195         ndr->depth--;
18196 }
18197
18198 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
18199 {
18200         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
18201 }
18202
18203 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
18204 {
18205         if (ndr_flags & NDR_SCALARS) {
18206                 NDR_CHECK(ndr_push_align(ndr, 5));
18207                 {
18208                         uint32_t _flags_save_string = ndr->flags;
18209                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18210                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
18211                         ndr->flags = _flags_save_string;
18212                 }
18213                 {
18214                         uint32_t _flags_save_string = ndr->flags;
18215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18216                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
18217                         ndr->flags = _flags_save_string;
18218                 }
18219                 {
18220                         uint32_t _flags_save_string = ndr->flags;
18221                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18222                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
18223                         ndr->flags = _flags_save_string;
18224                 }
18225                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18226         }
18227         if (ndr_flags & NDR_BUFFERS) {
18228                 {
18229                         uint32_t _flags_save_string = ndr->flags;
18230                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18231                         if (r->monitor_name) {
18232                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
18233                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
18234                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
18235                         }
18236                         ndr->flags = _flags_save_string;
18237                 }
18238                 {
18239                         uint32_t _flags_save_string = ndr->flags;
18240                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18241                         if (r->environment) {
18242                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->environment));
18243                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
18244                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->environment));
18245                         }
18246                         ndr->flags = _flags_save_string;
18247                 }
18248                 {
18249                         uint32_t _flags_save_string = ndr->flags;
18250                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18251                         if (r->dll_name) {
18252                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dll_name));
18253                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
18254                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dll_name));
18255                         }
18256                         ndr->flags = _flags_save_string;
18257                 }
18258         }
18259         return NDR_ERR_SUCCESS;
18260 }
18261
18262 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
18263 {
18264         uint32_t _ptr_monitor_name;
18265         TALLOC_CTX *_mem_save_monitor_name_0;
18266         uint32_t _ptr_environment;
18267         TALLOC_CTX *_mem_save_environment_0;
18268         uint32_t _ptr_dll_name;
18269         TALLOC_CTX *_mem_save_dll_name_0;
18270         if (ndr_flags & NDR_SCALARS) {
18271                 NDR_CHECK(ndr_pull_align(ndr, 5));
18272                 {
18273                         uint32_t _flags_save_string = ndr->flags;
18274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18275                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
18276                         if (_ptr_monitor_name) {
18277                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
18278                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
18279                         } else {
18280                                 r->monitor_name = NULL;
18281                         }
18282                         ndr->flags = _flags_save_string;
18283                 }
18284                 {
18285                         uint32_t _flags_save_string = ndr->flags;
18286                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18287                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
18288                         if (_ptr_environment) {
18289                                 NDR_PULL_ALLOC(ndr, r->environment);
18290                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
18291                         } else {
18292                                 r->environment = NULL;
18293                         }
18294                         ndr->flags = _flags_save_string;
18295                 }
18296                 {
18297                         uint32_t _flags_save_string = ndr->flags;
18298                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18299                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
18300                         if (_ptr_dll_name) {
18301                                 NDR_PULL_ALLOC(ndr, r->dll_name);
18302                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
18303                         } else {
18304                                 r->dll_name = NULL;
18305                         }
18306                         ndr->flags = _flags_save_string;
18307                 }
18308                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18309         }
18310         if (ndr_flags & NDR_BUFFERS) {
18311                 {
18312                         uint32_t _flags_save_string = ndr->flags;
18313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18314                         if (r->monitor_name) {
18315                                 uint32_t _relative_save_offset;
18316                                 _relative_save_offset = ndr->offset;
18317                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
18318                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18319                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
18320                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
18321                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
18322                                 if (ndr->offset > ndr->relative_highest_offset) {
18323                                         ndr->relative_highest_offset = ndr->offset;
18324                                 }
18325                                 ndr->offset = _relative_save_offset;
18326                         }
18327                         ndr->flags = _flags_save_string;
18328                 }
18329                 {
18330                         uint32_t _flags_save_string = ndr->flags;
18331                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18332                         if (r->environment) {
18333                                 uint32_t _relative_save_offset;
18334                                 _relative_save_offset = ndr->offset;
18335                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
18336                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
18337                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
18338                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
18339                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
18340                                 if (ndr->offset > ndr->relative_highest_offset) {
18341                                         ndr->relative_highest_offset = ndr->offset;
18342                                 }
18343                                 ndr->offset = _relative_save_offset;
18344                         }
18345                         ndr->flags = _flags_save_string;
18346                 }
18347                 {
18348                         uint32_t _flags_save_string = ndr->flags;
18349                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18350                         if (r->dll_name) {
18351                                 uint32_t _relative_save_offset;
18352                                 _relative_save_offset = ndr->offset;
18353                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
18354                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18355                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
18356                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
18357                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
18358                                 if (ndr->offset > ndr->relative_highest_offset) {
18359                                         ndr->relative_highest_offset = ndr->offset;
18360                                 }
18361                                 ndr->offset = _relative_save_offset;
18362                         }
18363                         ndr->flags = _flags_save_string;
18364                 }
18365         }
18366         return NDR_ERR_SUCCESS;
18367 }
18368
18369 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
18370 {
18371         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
18372         ndr->depth++;
18373         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
18374         ndr->depth++;
18375         if (r->monitor_name) {
18376                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
18377         }
18378         ndr->depth--;
18379         ndr_print_ptr(ndr, "environment", r->environment);
18380         ndr->depth++;
18381         if (r->environment) {
18382                 ndr_print_string(ndr, "environment", r->environment);
18383         }
18384         ndr->depth--;
18385         ndr_print_ptr(ndr, "dll_name", r->dll_name);
18386         ndr->depth++;
18387         if (r->dll_name) {
18388                 ndr_print_string(ndr, "dll_name", r->dll_name);
18389         }
18390         ndr->depth--;
18391         ndr->depth--;
18392 }
18393
18394 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
18395 {
18396         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
18397 }
18398
18399 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
18400 {
18401         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18402         {
18403                 uint32_t _flags_save_UNION = ndr->flags;
18404                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18405                 if (ndr_flags & NDR_SCALARS) {
18406                         int level = ndr_push_get_switch_value(ndr, r);
18407                         NDR_CHECK(ndr_push_union_align(ndr, 5));
18408                         switch (level) {
18409                                 case 1: {
18410                                         NDR_CHECK(ndr_push_align(ndr, 5));
18411                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18412                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
18413                                 break; }
18414
18415                                 case 2: {
18416                                         NDR_CHECK(ndr_push_align(ndr, 5));
18417                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18418                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
18419                                 break; }
18420
18421                                 default: {
18422                                 break; }
18423
18424                         }
18425                 }
18426                 if (ndr_flags & NDR_BUFFERS) {
18427                         int level = ndr_push_get_switch_value(ndr, r);
18428                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18429                         switch (level) {
18430                                 case 1:
18431                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
18432                                 break;
18433
18434                                 case 2:
18435                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
18436                                 break;
18437
18438                                 default:
18439                                 break;
18440
18441                         }
18442                 }
18443                 ndr->flags = _flags_save_UNION;
18444         }
18445         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18446         return NDR_ERR_SUCCESS;
18447 }
18448
18449 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
18450 {
18451         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18452         int level;
18453         {
18454                 uint32_t _flags_save_UNION = ndr->flags;
18455                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18456                 level = ndr_pull_get_switch_value(ndr, r);
18457                 if (ndr_flags & NDR_SCALARS) {
18458                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
18459                         switch (level) {
18460                                 case 1: {
18461                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18462                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18463                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
18464                                 break; }
18465
18466                                 case 2: {
18467                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18468                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18469                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
18470                                 break; }
18471
18472                                 default: {
18473                                 break; }
18474
18475                         }
18476                 }
18477                 if (ndr_flags & NDR_BUFFERS) {
18478                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18479                         switch (level) {
18480                                 case 1:
18481                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
18482                                 break;
18483
18484                                 case 2:
18485                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
18486                                 break;
18487
18488                                 default:
18489                                 break;
18490
18491                         }
18492                 }
18493                 ndr->flags = _flags_save_UNION;
18494         }
18495         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18496         return NDR_ERR_SUCCESS;
18497 }
18498
18499 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
18500 {
18501         int level;
18502         {
18503                 uint32_t _flags_save_UNION = ndr->flags;
18504                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18505                 level = ndr_print_get_switch_value(ndr, r);
18506                 ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
18507                 switch (level) {
18508                         case 1:
18509                                 ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
18510                         break;
18511
18512                         case 2:
18513                                 ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
18514                         break;
18515
18516                         default:
18517                         break;
18518
18519                 }
18520                 ndr->flags = _flags_save_UNION;
18521         }
18522 }
18523
18524 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
18525 {
18526         if (ndr_flags & NDR_SCALARS) {
18527                 NDR_CHECK(ndr_push_align(ndr, 5));
18528                 {
18529                         uint32_t _flags_save_string = ndr->flags;
18530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18531                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
18532                         ndr->flags = _flags_save_string;
18533                 }
18534                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18535         }
18536         if (ndr_flags & NDR_BUFFERS) {
18537                 {
18538                         uint32_t _flags_save_string = ndr->flags;
18539                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18540                         if (r->name_array) {
18541                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->name_array));
18542                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
18543                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->name_array));
18544                         }
18545                         ndr->flags = _flags_save_string;
18546                 }
18547         }
18548         return NDR_ERR_SUCCESS;
18549 }
18550
18551 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
18552 {
18553         uint32_t _ptr_name_array;
18554         TALLOC_CTX *_mem_save_name_array_0;
18555         if (ndr_flags & NDR_SCALARS) {
18556                 NDR_CHECK(ndr_pull_align(ndr, 5));
18557                 {
18558                         uint32_t _flags_save_string = ndr->flags;
18559                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18560                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
18561                         if (_ptr_name_array) {
18562                                 NDR_PULL_ALLOC(ndr, r->name_array);
18563                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
18564                         } else {
18565                                 r->name_array = NULL;
18566                         }
18567                         ndr->flags = _flags_save_string;
18568                 }
18569                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18570         }
18571         if (ndr_flags & NDR_BUFFERS) {
18572                 {
18573                         uint32_t _flags_save_string = ndr->flags;
18574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18575                         if (r->name_array) {
18576                                 uint32_t _relative_save_offset;
18577                                 _relative_save_offset = ndr->offset;
18578                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
18579                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
18580                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
18581                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
18582                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
18583                                 if (ndr->offset > ndr->relative_highest_offset) {
18584                                         ndr->relative_highest_offset = ndr->offset;
18585                                 }
18586                                 ndr->offset = _relative_save_offset;
18587                         }
18588                         ndr->flags = _flags_save_string;
18589                 }
18590         }
18591         return NDR_ERR_SUCCESS;
18592 }
18593
18594 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
18595 {
18596         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
18597         ndr->depth++;
18598         ndr_print_ptr(ndr, "name_array", r->name_array);
18599         ndr->depth++;
18600         if (r->name_array) {
18601                 ndr_print_string(ndr, "name_array", r->name_array);
18602         }
18603         ndr->depth--;
18604         ndr->depth--;
18605 }
18606
18607 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
18608 {
18609         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
18610 }
18611
18612 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
18613 {
18614         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18615         {
18616                 uint32_t _flags_save_UNION = ndr->flags;
18617                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18618                 if (ndr_flags & NDR_SCALARS) {
18619                         int level = ndr_push_get_switch_value(ndr, r);
18620                         NDR_CHECK(ndr_push_union_align(ndr, 5));
18621                         switch (level) {
18622                                 case 1: {
18623                                         NDR_CHECK(ndr_push_align(ndr, 5));
18624                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18625                                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
18626                                 break; }
18627
18628                                 default: {
18629                                 break; }
18630
18631                         }
18632                 }
18633                 if (ndr_flags & NDR_BUFFERS) {
18634                         int level = ndr_push_get_switch_value(ndr, r);
18635                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18636                         switch (level) {
18637                                 case 1:
18638                                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
18639                                 break;
18640
18641                                 default:
18642                                 break;
18643
18644                         }
18645                 }
18646                 ndr->flags = _flags_save_UNION;
18647         }
18648         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18649         return NDR_ERR_SUCCESS;
18650 }
18651
18652 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
18653 {
18654         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18655         int level;
18656         {
18657                 uint32_t _flags_save_UNION = ndr->flags;
18658                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18659                 level = ndr_pull_get_switch_value(ndr, r);
18660                 if (ndr_flags & NDR_SCALARS) {
18661                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
18662                         switch (level) {
18663                                 case 1: {
18664                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18665                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18666                                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
18667                                 break; }
18668
18669                                 default: {
18670                                 break; }
18671
18672                         }
18673                 }
18674                 if (ndr_flags & NDR_BUFFERS) {
18675                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18676                         switch (level) {
18677                                 case 1:
18678                                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
18679                                 break;
18680
18681                                 default:
18682                                 break;
18683
18684                         }
18685                 }
18686                 ndr->flags = _flags_save_UNION;
18687         }
18688         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18689         return NDR_ERR_SUCCESS;
18690 }
18691
18692 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
18693 {
18694         int level;
18695         {
18696                 uint32_t _flags_save_UNION = ndr->flags;
18697                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18698                 level = ndr_print_get_switch_value(ndr, r);
18699                 ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
18700                 switch (level) {
18701                         case 1:
18702                                 ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
18703                         break;
18704
18705                         default:
18706                         break;
18707
18708                 }
18709                 ndr->flags = _flags_save_UNION;
18710         }
18711 }
18712
18713 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18714 {
18715         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18716         return NDR_ERR_SUCCESS;
18717 }
18718
18719 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18720 {
18721         uint32_t v;
18722         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18723         *r = v;
18724         return NDR_ERR_SUCCESS;
18725 }
18726
18727 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18728 {
18729         ndr_print_uint32(ndr, name, r);
18730         ndr->depth++;
18731         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
18732         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
18733         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
18734         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
18735         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
18736         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
18737         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
18738         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
18739         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
18740         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
18741         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
18742         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
18743         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
18744         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
18745         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
18746         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
18747         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
18748         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
18749         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
18750         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
18751         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
18752         ndr->depth--;
18753 }
18754
18755 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobNotifyField r)
18756 {
18757         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18758         return NDR_ERR_SUCCESS;
18759 }
18760
18761 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobNotifyField *r)
18762 {
18763         uint16_t v;
18764         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18765         *r = v;
18766         return NDR_ERR_SUCCESS;
18767 }
18768
18769 _PUBLIC_ void ndr_print_spoolss_JobNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_JobNotifyField r)
18770 {
18771         const char *val = NULL;
18772
18773         switch (r) {
18774                 case JOB_NOTIFY_FIELD_PRINTER_NAME: val = "JOB_NOTIFY_FIELD_PRINTER_NAME"; break;
18775                 case JOB_NOTIFY_FIELD_MACHINE_NAME: val = "JOB_NOTIFY_FIELD_MACHINE_NAME"; break;
18776                 case JOB_NOTIFY_FIELD_PORT_NAME: val = "JOB_NOTIFY_FIELD_PORT_NAME"; break;
18777                 case JOB_NOTIFY_FIELD_USER_NAME: val = "JOB_NOTIFY_FIELD_USER_NAME"; break;
18778                 case JOB_NOTIFY_FIELD_NOTIFY_NAME: val = "JOB_NOTIFY_FIELD_NOTIFY_NAME"; break;
18779                 case JOB_NOTIFY_FIELD_DATATYPE: val = "JOB_NOTIFY_FIELD_DATATYPE"; break;
18780                 case JOB_NOTIFY_FIELD_PRINT_PROCESSOR: val = "JOB_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18781                 case JOB_NOTIFY_FIELD_PARAMETERS: val = "JOB_NOTIFY_FIELD_PARAMETERS"; break;
18782                 case JOB_NOTIFY_FIELD_DRIVER_NAME: val = "JOB_NOTIFY_FIELD_DRIVER_NAME"; break;
18783                 case JOB_NOTIFY_FIELD_DEVMODE: val = "JOB_NOTIFY_FIELD_DEVMODE"; break;
18784                 case JOB_NOTIFY_FIELD_STATUS: val = "JOB_NOTIFY_FIELD_STATUS"; break;
18785                 case JOB_NOTIFY_FIELD_STATUS_STRING: val = "JOB_NOTIFY_FIELD_STATUS_STRING"; break;
18786                 case JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18787                 case JOB_NOTIFY_FIELD_DOCUMENT: val = "JOB_NOTIFY_FIELD_DOCUMENT"; break;
18788                 case JOB_NOTIFY_FIELD_PRIORITY: val = "JOB_NOTIFY_FIELD_PRIORITY"; break;
18789                 case JOB_NOTIFY_FIELD_POSITION: val = "JOB_NOTIFY_FIELD_POSITION"; break;
18790                 case JOB_NOTIFY_FIELD_SUBMITTED: val = "JOB_NOTIFY_FIELD_SUBMITTED"; break;
18791                 case JOB_NOTIFY_FIELD_START_TIME: val = "JOB_NOTIFY_FIELD_START_TIME"; break;
18792                 case JOB_NOTIFY_FIELD_UNTIL_TIME: val = "JOB_NOTIFY_FIELD_UNTIL_TIME"; break;
18793                 case JOB_NOTIFY_FIELD_TIME: val = "JOB_NOTIFY_FIELD_TIME"; break;
18794                 case JOB_NOTIFY_FIELD_TOTAL_PAGES: val = "JOB_NOTIFY_FIELD_TOTAL_PAGES"; break;
18795                 case JOB_NOTIFY_FIELD_PAGES_PRINTED: val = "JOB_NOTIFY_FIELD_PAGES_PRINTED"; break;
18796                 case JOB_NOTIFY_FIELD_TOTAL_BYTES: val = "JOB_NOTIFY_FIELD_TOTAL_BYTES"; break;
18797                 case JOB_NOTIFY_FIELD_BYTES_PRINTED: val = "JOB_NOTIFY_FIELD_BYTES_PRINTED"; break;
18798         }
18799         ndr_print_enum(ndr, name, "ENUM", val, r);
18800 }
18801
18802 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrintNotifyField r)
18803 {
18804         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18805         return NDR_ERR_SUCCESS;
18806 }
18807
18808 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrintNotifyField *r)
18809 {
18810         uint16_t v;
18811         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18812         *r = v;
18813         return NDR_ERR_SUCCESS;
18814 }
18815
18816 _PUBLIC_ void ndr_print_spoolss_PrintNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_PrintNotifyField r)
18817 {
18818         const char *val = NULL;
18819
18820         switch (r) {
18821                 case PRINTER_NOTIFY_FIELD_SERVER_NAME: val = "PRINTER_NOTIFY_FIELD_SERVER_NAME"; break;
18822                 case PRINTER_NOTIFY_FIELD_PRINTER_NAME: val = "PRINTER_NOTIFY_FIELD_PRINTER_NAME"; break;
18823                 case PRINTER_NOTIFY_FIELD_SHARE_NAME: val = "PRINTER_NOTIFY_FIELD_SHARE_NAME"; break;
18824                 case PRINTER_NOTIFY_FIELD_PORT_NAME: val = "PRINTER_NOTIFY_FIELD_PORT_NAME"; break;
18825                 case PRINTER_NOTIFY_FIELD_DRIVER_NAME: val = "PRINTER_NOTIFY_FIELD_DRIVER_NAME"; break;
18826                 case PRINTER_NOTIFY_FIELD_COMMENT: val = "PRINTER_NOTIFY_FIELD_COMMENT"; break;
18827                 case PRINTER_NOTIFY_FIELD_LOCATION: val = "PRINTER_NOTIFY_FIELD_LOCATION"; break;
18828                 case PRINTER_NOTIFY_FIELD_DEVMODE: val = "PRINTER_NOTIFY_FIELD_DEVMODE"; break;
18829                 case PRINTER_NOTIFY_FIELD_SEPFILE: val = "PRINTER_NOTIFY_FIELD_SEPFILE"; break;
18830                 case PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: val = "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18831                 case PRINTER_NOTIFY_FIELD_PARAMETERS: val = "PRINTER_NOTIFY_FIELD_PARAMETERS"; break;
18832                 case PRINTER_NOTIFY_FIELD_DATATYPE: val = "PRINTER_NOTIFY_FIELD_DATATYPE"; break;
18833                 case PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18834                 case PRINTER_NOTIFY_FIELD_ATTRIBUTES: val = "PRINTER_NOTIFY_FIELD_ATTRIBUTES"; break;
18835                 case PRINTER_NOTIFY_FIELD_PRIORITY: val = "PRINTER_NOTIFY_FIELD_PRIORITY"; break;
18836                 case PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: val = "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY"; break;
18837                 case PRINTER_NOTIFY_FIELD_START_TIME: val = "PRINTER_NOTIFY_FIELD_START_TIME"; break;
18838                 case PRINTER_NOTIFY_FIELD_UNTIL_TIME: val = "PRINTER_NOTIFY_FIELD_UNTIL_TIME"; break;
18839                 case PRINTER_NOTIFY_FIELD_STATUS: val = "PRINTER_NOTIFY_FIELD_STATUS"; break;
18840                 case PRINTER_NOTIFY_FIELD_STATUS_STRING: val = "PRINTER_NOTIFY_FIELD_STATUS_STRING"; break;
18841                 case PRINTER_NOTIFY_FIELD_CJOBS: val = "PRINTER_NOTIFY_FIELD_CJOBS"; break;
18842                 case PRINTER_NOTIFY_FIELD_AVERAGE_PPM: val = "PRINTER_NOTIFY_FIELD_AVERAGE_PPM"; break;
18843                 case PRINTER_NOTIFY_FIELD_TOTAL_PAGES: val = "PRINTER_NOTIFY_FIELD_TOTAL_PAGES"; break;
18844                 case PRINTER_NOTIFY_FIELD_PAGES_PRINTED: val = "PRINTER_NOTIFY_FIELD_PAGES_PRINTED"; break;
18845                 case PRINTER_NOTIFY_FIELD_TOTAL_BYTES: val = "PRINTER_NOTIFY_FIELD_TOTAL_BYTES"; break;
18846                 case PRINTER_NOTIFY_FIELD_BYTES_PRINTED: val = "PRINTER_NOTIFY_FIELD_BYTES_PRINTED"; break;
18847                 case PRINTER_NOTIFY_FIELD_OBJECT_GUID: val = "PRINTER_NOTIFY_FIELD_OBJECT_GUID"; break;
18848                 case PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: val = "PRINTER_NOTIFY_FIELD_FRIENDLY_NAME"; break;
18849         }
18850         ndr_print_enum(ndr, name, "ENUM", val, r);
18851 }
18852
18853 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
18854 {
18855         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18856         return NDR_ERR_SUCCESS;
18857 }
18858
18859 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
18860 {
18861         uint16_t v;
18862         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18863         *r = v;
18864         return NDR_ERR_SUCCESS;
18865 }
18866
18867 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
18868 {
18869         const char *val = NULL;
18870
18871         switch (r) {
18872                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
18873                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
18874         }
18875         ndr_print_enum(ndr, name, "ENUM", val, r);
18876 }
18877
18878 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, const union spoolss_Field *r)
18879 {
18880         if (ndr_flags & NDR_SCALARS) {
18881                 int level = ndr_push_get_switch_value(ndr, r);
18882                 NDR_CHECK(ndr_push_union_align(ndr, 2));
18883                 switch (level) {
18884                         case PRINTER_NOTIFY_TYPE: {
18885                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18886                         break; }
18887
18888                         case JOB_NOTIFY_TYPE: {
18889                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18890                         break; }
18891
18892                         default: {
18893                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18894                         break; }
18895
18896                 }
18897         }
18898         if (ndr_flags & NDR_BUFFERS) {
18899                 int level = ndr_push_get_switch_value(ndr, r);
18900                 switch (level) {
18901                         case PRINTER_NOTIFY_TYPE:
18902                         break;
18903
18904                         case JOB_NOTIFY_TYPE:
18905                         break;
18906
18907                         default:
18908                         break;
18909
18910                 }
18911         }
18912         return NDR_ERR_SUCCESS;
18913 }
18914
18915 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, union spoolss_Field *r)
18916 {
18917         int level;
18918         level = ndr_pull_get_switch_value(ndr, r);
18919         if (ndr_flags & NDR_SCALARS) {
18920                 NDR_CHECK(ndr_pull_union_align(ndr, 2));
18921                 switch (level) {
18922                         case PRINTER_NOTIFY_TYPE: {
18923                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18924                         break; }
18925
18926                         case JOB_NOTIFY_TYPE: {
18927                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18928                         break; }
18929
18930                         default: {
18931                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18932                         break; }
18933
18934                 }
18935         }
18936         if (ndr_flags & NDR_BUFFERS) {
18937                 switch (level) {
18938                         case PRINTER_NOTIFY_TYPE:
18939                         break;
18940
18941                         case JOB_NOTIFY_TYPE:
18942                         break;
18943
18944                         default:
18945                         break;
18946
18947                 }
18948         }
18949         return NDR_ERR_SUCCESS;
18950 }
18951
18952 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
18953 {
18954         uint32_t cntr_fields_1;
18955         if (ndr_flags & NDR_SCALARS) {
18956                 NDR_CHECK(ndr_push_align(ndr, 5));
18957                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18958                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
18959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
18960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
18961                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18962                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
18963                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18964         }
18965         if (ndr_flags & NDR_BUFFERS) {
18966                 if (r->fields) {
18967                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18968                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
18969                                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
18970                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
18971                         }
18972                 }
18973         }
18974         return NDR_ERR_SUCCESS;
18975 }
18976
18977 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
18978 {
18979         uint32_t _ptr_fields;
18980         uint32_t cntr_fields_1;
18981         TALLOC_CTX *_mem_save_fields_0;
18982         TALLOC_CTX *_mem_save_fields_1;
18983         if (ndr_flags & NDR_SCALARS) {
18984                 NDR_CHECK(ndr_pull_align(ndr, 5));
18985                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18986                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
18987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
18988                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
18989                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18990                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
18991                 if (_ptr_fields) {
18992                         NDR_PULL_ALLOC(ndr, r->fields);
18993                 } else {
18994                         r->fields = NULL;
18995                 }
18996                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18997         }
18998         if (ndr_flags & NDR_BUFFERS) {
18999                 if (r->fields) {
19000                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
19001                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
19002                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
19003                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
19004                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
19005                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
19006                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
19007                                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
19008                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
19009                         }
19010                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
19011                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
19012                 }
19013                 if (r->fields) {
19014                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
19015                 }
19016         }
19017         return NDR_ERR_SUCCESS;
19018 }
19019
19020 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
19021 {
19022         uint32_t cntr_fields_1;
19023         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
19024         ndr->depth++;
19025         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
19026         ndr_print_uint16(ndr, "u1", r->u1);
19027         ndr_print_uint32(ndr, "u2", r->u2);
19028         ndr_print_uint32(ndr, "u3", r->u3);
19029         ndr_print_uint32(ndr, "count", r->count);
19030         ndr_print_ptr(ndr, "fields", r->fields);
19031         ndr->depth++;
19032         if (r->fields) {
19033                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
19034                 ndr->depth++;
19035                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
19036                         char *idx_1=NULL;
19037                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
19038                                 ndr_print_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type);
19039                                 ndr_print_spoolss_Field(ndr, "fields", &r->fields[cntr_fields_1]);
19040                                 free(idx_1);
19041                         }
19042                 }
19043                 ndr->depth--;
19044         }
19045         ndr->depth--;
19046         ndr->depth--;
19047 }
19048
19049 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19050 {
19051         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19052         return NDR_ERR_SUCCESS;
19053 }
19054
19055 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19056 {
19057         uint32_t v;
19058         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19059         *r = v;
19060         return NDR_ERR_SUCCESS;
19061 }
19062
19063 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19064 {
19065         ndr_print_uint32(ndr, name, r);
19066         ndr->depth++;
19067         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
19068         ndr->depth--;
19069 }
19070
19071 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
19072 {
19073         uint32_t cntr_types_1;
19074         if (ndr_flags & NDR_SCALARS) {
19075                 NDR_CHECK(ndr_push_align(ndr, 5));
19076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
19077                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
19078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
19079                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
19080                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19081         }
19082         if (ndr_flags & NDR_BUFFERS) {
19083                 if (r->types) {
19084                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
19085                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
19086                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
19087                         }
19088                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
19089                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
19090                         }
19091                 }
19092         }
19093         return NDR_ERR_SUCCESS;
19094 }
19095
19096 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
19097 {
19098         uint32_t _ptr_types;
19099         uint32_t cntr_types_1;
19100         TALLOC_CTX *_mem_save_types_0;
19101         TALLOC_CTX *_mem_save_types_1;
19102         if (ndr_flags & NDR_SCALARS) {
19103                 NDR_CHECK(ndr_pull_align(ndr, 5));
19104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19105                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
19106                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
19107                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
19108                 if (_ptr_types) {
19109                         NDR_PULL_ALLOC(ndr, r->types);
19110                 } else {
19111                         r->types = NULL;
19112                 }
19113                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19114         }
19115         if (ndr_flags & NDR_BUFFERS) {
19116                 if (r->types) {
19117                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
19118                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
19119                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
19120                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
19121                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
19122                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
19123                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
19124                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
19125                         }
19126                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
19127                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
19128                         }
19129                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
19130                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
19131                 }
19132                 if (r->types) {
19133                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
19134                 }
19135         }
19136         return NDR_ERR_SUCCESS;
19137 }
19138
19139 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
19140 {
19141         uint32_t cntr_types_1;
19142         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
19143         ndr->depth++;
19144         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
19145         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
19146         ndr_print_uint32(ndr, "count", r->count);
19147         ndr_print_ptr(ndr, "types", r->types);
19148         ndr->depth++;
19149         if (r->types) {
19150                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
19151                 ndr->depth++;
19152                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
19153                         char *idx_1=NULL;
19154                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
19155                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
19156                                 free(idx_1);
19157                         }
19158                 }
19159                 ndr->depth--;
19160         }
19161         ndr->depth--;
19162         ndr->depth--;
19163 }
19164
19165 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
19166 {
19167         if (ndr_flags & NDR_SCALARS) {
19168                 NDR_CHECK(ndr_push_align(ndr, 5));
19169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19170                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
19171                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19172         }
19173         if (ndr_flags & NDR_BUFFERS) {
19174                 if (r->string) {
19175                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size / 2));
19176                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
19177                 }
19178         }
19179         return NDR_ERR_SUCCESS;
19180 }
19181
19182 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
19183 {
19184         uint32_t _ptr_string;
19185         TALLOC_CTX *_mem_save_string_0;
19186         if (ndr_flags & NDR_SCALARS) {
19187                 NDR_CHECK(ndr_pull_align(ndr, 5));
19188                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19189                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
19190                 if (_ptr_string) {
19191                         NDR_PULL_ALLOC(ndr, r->string);
19192                 } else {
19193                         r->string = NULL;
19194                 }
19195                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19196         }
19197         if (ndr_flags & NDR_BUFFERS) {
19198                 if (r->string) {
19199                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
19200                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
19201                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
19202                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
19203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
19204                 }
19205                 if (r->string) {
19206                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
19207                 }
19208         }
19209         return NDR_ERR_SUCCESS;
19210 }
19211
19212 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
19213 {
19214         ndr_print_struct(ndr, name, "spoolss_NotifyString");
19215         ndr->depth++;
19216         ndr_print_uint32(ndr, "size", r->size);
19217         ndr_print_ptr(ndr, "string", r->string);
19218         ndr->depth++;
19219         if (r->string) {
19220                 ndr_print_string(ndr, "string", r->string);
19221         }
19222         ndr->depth--;
19223         ndr->depth--;
19224 }
19225
19226 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
19227 {
19228         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
19229         return NDR_ERR_SUCCESS;
19230 }
19231
19232 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
19233 {
19234         uint32_t v;
19235         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
19236         *r = v;
19237         return NDR_ERR_SUCCESS;
19238 }
19239
19240 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
19241 {
19242         const char *val = NULL;
19243
19244         switch (r) {
19245                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
19246                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
19247                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
19248                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
19249                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
19250         }
19251         ndr_print_enum(ndr, name, "ENUM", val, r);
19252 }
19253
19254 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
19255 {
19256         if (ndr_flags & NDR_SCALARS) {
19257                 int level = ndr_push_get_switch_value(ndr, r);
19258                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19259                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19260                 switch (level) {
19261                         case 1: {
19262                                 uint32_t cntr_integer_0;
19263                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
19264                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
19265                                 }
19266                         break; }
19267
19268                         case 2: {
19269                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
19270                         break; }
19271
19272                         case 3: {
19273                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
19274                         break; }
19275
19276                         case 4: {
19277                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
19278                         break; }
19279
19280                         case 5: {
19281                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
19282                         break; }
19283
19284                         default:
19285                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19286                 }
19287         }
19288         if (ndr_flags & NDR_BUFFERS) {
19289                 int level = ndr_push_get_switch_value(ndr, r);
19290                 switch (level) {
19291                         case 1:
19292                         break;
19293
19294                         case 2:
19295                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
19296                         break;
19297
19298                         case 3:
19299                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
19300                         break;
19301
19302                         case 4:
19303                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
19304                         break;
19305
19306                         case 5:
19307                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
19308                         break;
19309
19310                         default:
19311                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19312                 }
19313         }
19314         return NDR_ERR_SUCCESS;
19315 }
19316
19317 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
19318 {
19319         int level;
19320         uint32_t _level;
19321         level = ndr_pull_get_switch_value(ndr, r);
19322         if (ndr_flags & NDR_SCALARS) {
19323                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19324                 if (_level != level) {
19325                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19326                 }
19327                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19328                 switch (level) {
19329                         case 1: {
19330                                 uint32_t cntr_integer_0;
19331                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
19332                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
19333                                 }
19334                         break; }
19335
19336                         case 2: {
19337                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
19338                         break; }
19339
19340                         case 3: {
19341                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
19342                         break; }
19343
19344                         case 4: {
19345                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
19346                         break; }
19347
19348                         case 5: {
19349                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
19350                         break; }
19351
19352                         default:
19353                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19354                 }
19355         }
19356         if (ndr_flags & NDR_BUFFERS) {
19357                 switch (level) {
19358                         case 1:
19359                         break;
19360
19361                         case 2:
19362                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
19363                         break;
19364
19365                         case 3:
19366                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
19367                         break;
19368
19369                         case 4:
19370                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
19371                         break;
19372
19373                         case 5:
19374                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
19375                         break;
19376
19377                         default:
19378                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19379                 }
19380         }
19381         return NDR_ERR_SUCCESS;
19382 }
19383
19384 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
19385 {
19386         int level;
19387         uint32_t cntr_integer_0;
19388         level = ndr_print_get_switch_value(ndr, r);
19389         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
19390         switch (level) {
19391                 case 1:
19392                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
19393                         ndr->depth++;
19394                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
19395                                 char *idx_0=NULL;
19396                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
19397                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
19398                                         free(idx_0);
19399                                 }
19400                         }
19401                         ndr->depth--;
19402                 break;
19403
19404                 case 2:
19405                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
19406                 break;
19407
19408                 case 3:
19409                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
19410                 break;
19411
19412                 case 4:
19413                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
19414                 break;
19415
19416                 case 5:
19417                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
19418                 break;
19419
19420                 default:
19421                         ndr_print_bad_level(ndr, name, level);
19422         }
19423 }
19424
19425 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
19426 {
19427         if (ndr_flags & NDR_SCALARS) {
19428                 NDR_CHECK(ndr_push_align(ndr, 5));
19429                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
19430                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->field, r->type));
19431                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->field));
19432                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
19433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
19434                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
19435                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
19436                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19437         }
19438         if (ndr_flags & NDR_BUFFERS) {
19439                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
19440         }
19441         return NDR_ERR_SUCCESS;
19442 }
19443
19444 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
19445 {
19446         if (ndr_flags & NDR_SCALARS) {
19447                 NDR_CHECK(ndr_pull_align(ndr, 5));
19448                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
19449                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->field, r->type));
19450                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
19451                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
19452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
19453                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
19454                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
19455                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19456         }
19457         if (ndr_flags & NDR_BUFFERS) {
19458                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
19459         }
19460         return NDR_ERR_SUCCESS;
19461 }
19462
19463 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
19464 {
19465         ndr_print_struct(ndr, name, "spoolss_Notify");
19466         ndr->depth++;
19467         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
19468         ndr_print_set_switch_value(ndr, &r->field, r->type);
19469         ndr_print_spoolss_Field(ndr, "field", &r->field);
19470         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
19471         ndr_print_uint32(ndr, "job_id", r->job_id);
19472         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
19473         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
19474         ndr->depth--;
19475 }
19476
19477 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
19478 {
19479         uint32_t cntr_notifies_0;
19480         if (ndr_flags & NDR_SCALARS) {
19481                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
19482                 NDR_CHECK(ndr_push_align(ndr, 5));
19483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
19484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
19485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
19486                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19487                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
19488                 }
19489                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19490         }
19491         if (ndr_flags & NDR_BUFFERS) {
19492                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19493                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
19494                 }
19495         }
19496         return NDR_ERR_SUCCESS;
19497 }
19498
19499 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
19500 {
19501         uint32_t cntr_notifies_0;
19502         TALLOC_CTX *_mem_save_notifies_0;
19503         if (ndr_flags & NDR_SCALARS) {
19504                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
19505                 NDR_CHECK(ndr_pull_align(ndr, 5));
19506                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19507                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
19508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
19509                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
19510                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
19511                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
19512                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19513                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
19514                 }
19515                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
19516                 if (r->notifies) {
19517                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
19518                 }
19519                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19520         }
19521         if (ndr_flags & NDR_BUFFERS) {
19522                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
19523                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
19524                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19525                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
19526                 }
19527                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
19528         }
19529         return NDR_ERR_SUCCESS;
19530 }
19531
19532 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
19533 {
19534         uint32_t cntr_notifies_0;
19535         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
19536         ndr->depth++;
19537         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
19538         ndr_print_uint32(ndr, "flags", r->flags);
19539         ndr_print_uint32(ndr, "count", r->count);
19540         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
19541         ndr->depth++;
19542         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
19543                 char *idx_0=NULL;
19544                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
19545                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
19546                         free(idx_0);
19547                 }
19548         }
19549         ndr->depth--;
19550         ndr->depth--;
19551 }
19552
19553 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
19554 {
19555         if (ndr_flags & NDR_SCALARS) {
19556                 int level = ndr_push_get_switch_value(ndr, r);
19557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19558                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19559                 switch (level) {
19560                         case 0: {
19561                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
19562                         break; }
19563
19564                         default:
19565                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19566                 }
19567         }
19568         if (ndr_flags & NDR_BUFFERS) {
19569                 int level = ndr_push_get_switch_value(ndr, r);
19570                 switch (level) {
19571                         case 0:
19572                                 if (r->info0) {
19573                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
19574                                 }
19575                         break;
19576
19577                         default:
19578                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19579                 }
19580         }
19581         return NDR_ERR_SUCCESS;
19582 }
19583
19584 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
19585 {
19586         int level;
19587         uint32_t _level;
19588         TALLOC_CTX *_mem_save_info0_0;
19589         level = ndr_pull_get_switch_value(ndr, r);
19590         if (ndr_flags & NDR_SCALARS) {
19591                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19592                 if (_level != level) {
19593                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19594                 }
19595                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19596                 switch (level) {
19597                         case 0: {
19598                                 uint32_t _ptr_info0;
19599                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
19600                                 if (_ptr_info0) {
19601                                         NDR_PULL_ALLOC(ndr, r->info0);
19602                                 } else {
19603                                         r->info0 = NULL;
19604                                 }
19605                         break; }
19606
19607                         default:
19608                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19609                 }
19610         }
19611         if (ndr_flags & NDR_BUFFERS) {
19612                 switch (level) {
19613                         case 0:
19614                                 if (r->info0) {
19615                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
19616                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
19617                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
19618                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
19619                                 }
19620                         break;
19621
19622                         default:
19623                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19624                 }
19625         }
19626         return NDR_ERR_SUCCESS;
19627 }
19628
19629 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
19630 {
19631         int level;
19632         level = ndr_print_get_switch_value(ndr, r);
19633         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
19634         switch (level) {
19635                 case 0:
19636                         ndr_print_ptr(ndr, "info0", r->info0);
19637                         ndr->depth++;
19638                         if (r->info0) {
19639                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
19640                         }
19641                         ndr->depth--;
19642                 break;
19643
19644                 default:
19645                         ndr_print_bad_level(ndr, name, level);
19646         }
19647 }
19648
19649 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19650 {
19651         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19652         return NDR_ERR_SUCCESS;
19653 }
19654
19655 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19656 {
19657         uint32_t v;
19658         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19659         *r = v;
19660         return NDR_ERR_SUCCESS;
19661 }
19662
19663 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19664 {
19665         ndr_print_uint32(ndr, name, r);
19666         ndr->depth++;
19667         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
19668         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
19669         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
19670         ndr->depth--;
19671 }
19672
19673 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
19674 {
19675         if (ndr_flags & NDR_SCALARS) {
19676                 NDR_CHECK(ndr_push_align(ndr, 5));
19677                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19678                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
19679                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
19680                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
19681                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
19682                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
19683                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
19684                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19685         }
19686         if (ndr_flags & NDR_BUFFERS) {
19687                 if (r->client) {
19688                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19689                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19690                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19691                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19692                 }
19693                 if (r->user) {
19694                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19695                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19696                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19697                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19698                 }
19699         }
19700         return NDR_ERR_SUCCESS;
19701 }
19702
19703 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
19704 {
19705         uint32_t _ptr_client;
19706         TALLOC_CTX *_mem_save_client_0;
19707         uint32_t _ptr_user;
19708         TALLOC_CTX *_mem_save_user_0;
19709         if (ndr_flags & NDR_SCALARS) {
19710                 NDR_CHECK(ndr_pull_align(ndr, 5));
19711                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19712                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19713                 if (_ptr_client) {
19714                         NDR_PULL_ALLOC(ndr, r->client);
19715                 } else {
19716                         r->client = NULL;
19717                 }
19718                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19719                 if (_ptr_user) {
19720                         NDR_PULL_ALLOC(ndr, r->user);
19721                 } else {
19722                         r->user = NULL;
19723                 }
19724                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19725                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19726                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19727                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19728                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19729         }
19730         if (ndr_flags & NDR_BUFFERS) {
19731                 if (r->client) {
19732                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19733                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19734                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19735                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19736                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19737                                 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));
19738                         }
19739                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19740                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19741                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19742                 }
19743                 if (r->user) {
19744                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19745                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19746                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19747                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19748                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19749                                 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));
19750                         }
19751                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19752                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19753                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19754                 }
19755         }
19756         return NDR_ERR_SUCCESS;
19757 }
19758
19759 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
19760 {
19761         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
19762         ndr->depth++;
19763         ndr_print_uint32(ndr, "size", r->size);
19764         ndr_print_ptr(ndr, "client", r->client);
19765         ndr->depth++;
19766         if (r->client) {
19767                 ndr_print_string(ndr, "client", r->client);
19768         }
19769         ndr->depth--;
19770         ndr_print_ptr(ndr, "user", r->user);
19771         ndr->depth++;
19772         if (r->user) {
19773                 ndr_print_string(ndr, "user", r->user);
19774         }
19775         ndr->depth--;
19776         ndr_print_uint32(ndr, "build", r->build);
19777         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19778         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19779         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19780         ndr->depth--;
19781 }
19782
19783 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
19784 {
19785         if (ndr_flags & NDR_SCALARS) {
19786                 NDR_CHECK(ndr_push_align(ndr, 4));
19787                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
19788                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19789         }
19790         if (ndr_flags & NDR_BUFFERS) {
19791         }
19792         return NDR_ERR_SUCCESS;
19793 }
19794
19795 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
19796 {
19797         if (ndr_flags & NDR_SCALARS) {
19798                 NDR_CHECK(ndr_pull_align(ndr, 4));
19799                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
19800                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19801         }
19802         if (ndr_flags & NDR_BUFFERS) {
19803         }
19804         return NDR_ERR_SUCCESS;
19805 }
19806
19807 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
19808 {
19809         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
19810         ndr->depth++;
19811         ndr_print_uint32(ndr, "not_used", r->not_used);
19812         ndr->depth--;
19813 }
19814
19815 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
19816 {
19817         if (ndr_flags & NDR_SCALARS) {
19818                 NDR_CHECK(ndr_push_align(ndr, 5));
19819                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
19821                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
19822                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
19823                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
19824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
19825                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
19826                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
19827                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
19828                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
19829                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19830         }
19831         if (ndr_flags & NDR_BUFFERS) {
19832                 if (r->client) {
19833                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19834                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19835                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19836                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19837                 }
19838                 if (r->user) {
19839                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19840                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19841                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19842                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19843                 }
19844         }
19845         return NDR_ERR_SUCCESS;
19846 }
19847
19848 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
19849 {
19850         uint32_t _ptr_client;
19851         TALLOC_CTX *_mem_save_client_0;
19852         uint32_t _ptr_user;
19853         TALLOC_CTX *_mem_save_user_0;
19854         if (ndr_flags & NDR_SCALARS) {
19855                 NDR_CHECK(ndr_pull_align(ndr, 5));
19856                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
19858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
19859                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19860                 if (_ptr_client) {
19861                         NDR_PULL_ALLOC(ndr, r->client);
19862                 } else {
19863                         r->client = NULL;
19864                 }
19865                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19866                 if (_ptr_user) {
19867                         NDR_PULL_ALLOC(ndr, r->user);
19868                 } else {
19869                         r->user = NULL;
19870                 }
19871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19872                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19873                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19874                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19875                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
19876                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19877         }
19878         if (ndr_flags & NDR_BUFFERS) {
19879                 if (r->client) {
19880                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19881                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19882                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19883                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19884                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19885                                 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));
19886                         }
19887                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19888                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19889                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19890                 }
19891                 if (r->user) {
19892                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19893                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19894                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19895                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19896                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19897                                 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));
19898                         }
19899                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19900                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19901                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19902                 }
19903         }
19904         return NDR_ERR_SUCCESS;
19905 }
19906
19907 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
19908 {
19909         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
19910         ndr->depth++;
19911         ndr_print_uint32(ndr, "size", r->size);
19912         ndr_print_uint32(ndr, "flags", r->flags);
19913         ndr_print_uint32(ndr, "size2", r->size2);
19914         ndr_print_ptr(ndr, "client", r->client);
19915         ndr->depth++;
19916         if (r->client) {
19917                 ndr_print_string(ndr, "client", r->client);
19918         }
19919         ndr->depth--;
19920         ndr_print_ptr(ndr, "user", r->user);
19921         ndr->depth++;
19922         if (r->user) {
19923                 ndr_print_string(ndr, "user", r->user);
19924         }
19925         ndr->depth--;
19926         ndr_print_uint32(ndr, "build", r->build);
19927         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19928         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19929         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19930         ndr_print_udlong(ndr, "reserved", r->reserved);
19931         ndr->depth--;
19932 }
19933
19934 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
19935 {
19936         if (ndr_flags & NDR_SCALARS) {
19937                 int level = ndr_push_get_switch_value(ndr, r);
19938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19939                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19940                 switch (level) {
19941                         case 1: {
19942                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
19943                         break; }
19944
19945                         case 2: {
19946                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
19947                         break; }
19948
19949                         case 3: {
19950                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
19951                         break; }
19952
19953                         default:
19954                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19955                 }
19956         }
19957         if (ndr_flags & NDR_BUFFERS) {
19958                 int level = ndr_push_get_switch_value(ndr, r);
19959                 switch (level) {
19960                         case 1:
19961                                 if (r->level1) {
19962                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
19963                                 }
19964                         break;
19965
19966                         case 2:
19967                                 if (r->level2) {
19968                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
19969                                 }
19970                         break;
19971
19972                         case 3:
19973                                 if (r->level3) {
19974                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
19975                                 }
19976                         break;
19977
19978                         default:
19979                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19980                 }
19981         }
19982         return NDR_ERR_SUCCESS;
19983 }
19984
19985 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
19986 {
19987         int level;
19988         uint32_t _level;
19989         TALLOC_CTX *_mem_save_level1_0;
19990         TALLOC_CTX *_mem_save_level2_0;
19991         TALLOC_CTX *_mem_save_level3_0;
19992         level = ndr_pull_get_switch_value(ndr, r);
19993         if (ndr_flags & NDR_SCALARS) {
19994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19995                 if (_level != level) {
19996                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19997                 }
19998                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19999                 switch (level) {
20000                         case 1: {
20001                                 uint32_t _ptr_level1;
20002                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
20003                                 if (_ptr_level1) {
20004                                         NDR_PULL_ALLOC(ndr, r->level1);
20005                                 } else {
20006                                         r->level1 = NULL;
20007                                 }
20008                         break; }
20009
20010                         case 2: {
20011                                 uint32_t _ptr_level2;
20012                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
20013                                 if (_ptr_level2) {
20014                                         NDR_PULL_ALLOC(ndr, r->level2);
20015                                 } else {
20016                                         r->level2 = NULL;
20017                                 }
20018                         break; }
20019
20020                         case 3: {
20021                                 uint32_t _ptr_level3;
20022                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
20023                                 if (_ptr_level3) {
20024                                         NDR_PULL_ALLOC(ndr, r->level3);
20025                                 } else {
20026                                         r->level3 = NULL;
20027                                 }
20028                         break; }
20029
20030                         default:
20031                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
20032                 }
20033         }
20034         if (ndr_flags & NDR_BUFFERS) {
20035                 switch (level) {
20036                         case 1:
20037                                 if (r->level1) {
20038                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
20039                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
20040                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
20041                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
20042                                 }
20043                         break;
20044
20045                         case 2:
20046                                 if (r->level2) {
20047                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
20048                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
20049                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
20050                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
20051                                 }
20052                         break;
20053
20054                         case 3:
20055                                 if (r->level3) {
20056                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
20057                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
20058                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
20059                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
20060                                 }
20061                         break;
20062
20063                         default:
20064                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
20065                 }
20066         }
20067         return NDR_ERR_SUCCESS;
20068 }
20069
20070 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
20071 {
20072         int level;
20073         level = ndr_print_get_switch_value(ndr, r);
20074         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
20075         switch (level) {
20076                 case 1:
20077                         ndr_print_ptr(ndr, "level1", r->level1);
20078                         ndr->depth++;
20079                         if (r->level1) {
20080                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
20081                         }
20082                         ndr->depth--;
20083                 break;
20084
20085                 case 2:
20086                         ndr_print_ptr(ndr, "level2", r->level2);
20087                         ndr->depth++;
20088                         if (r->level2) {
20089                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
20090                         }
20091                         ndr->depth--;
20092                 break;
20093
20094                 case 3:
20095                         ndr_print_ptr(ndr, "level3", r->level3);
20096                         ndr->depth++;
20097                         if (r->level3) {
20098                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
20099                         }
20100                         ndr->depth--;
20101                 break;
20102
20103                 default:
20104                         ndr_print_bad_level(ndr, name, level);
20105         }
20106 }
20107
20108 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
20109 {
20110         if (ndr_flags & NDR_SCALARS) {
20111                 NDR_CHECK(ndr_push_align(ndr, 5));
20112                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
20113                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
20114                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
20115                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
20116         }
20117         if (ndr_flags & NDR_BUFFERS) {
20118                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
20119         }
20120         return NDR_ERR_SUCCESS;
20121 }
20122
20123 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
20124 {
20125         if (ndr_flags & NDR_SCALARS) {
20126                 NDR_CHECK(ndr_pull_align(ndr, 5));
20127                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
20128                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
20129                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
20130                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
20131         }
20132         if (ndr_flags & NDR_BUFFERS) {
20133                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
20134         }
20135         return NDR_ERR_SUCCESS;
20136 }
20137
20138 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
20139 {
20140         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
20141         ndr->depth++;
20142         ndr_print_uint32(ndr, "level", r->level);
20143         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
20144         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
20145         ndr->depth--;
20146 }
20147
20148 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
20149 {
20150         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
20151         return NDR_ERR_SUCCESS;
20152 }
20153
20154 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
20155 {
20156         uint32_t v;
20157         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
20158         *r = v;
20159         return NDR_ERR_SUCCESS;
20160 }
20161
20162 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
20163 {
20164         ndr_print_uint32(ndr, name, r);
20165         ndr->depth++;
20166         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
20167         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
20168         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
20169         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
20170         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
20171         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
20172         ndr->depth--;
20173 }
20174
20175 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
20176 {
20177         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
20178         if (ndr_flags & NDR_SCALARS) {
20179                 NDR_CHECK(ndr_push_align(ndr, 5));
20180                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
20181                 {
20182                         uint32_t _flags_save_string = ndr->flags;
20183                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20184                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
20185                         ndr->flags = _flags_save_string;
20186                 }
20187                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
20188                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
20189                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
20190                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags)));
20191                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
20192         }
20193         if (ndr_flags & NDR_BUFFERS) {
20194                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
20195                 {
20196                         uint32_t _flags_save_string = ndr->flags;
20197                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20198                         if (r->value_name) {
20199                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->value_name));
20200                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
20201                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->value_name));
20202                         }
20203                         ndr->flags = _flags_save_string;
20204                 }
20205                 if (r->data) {
20206                         NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data));
20207                         {
20208                                 struct ndr_push *_ndr_data;
20209                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
20210                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_data, r->data, r->type));
20211                                 NDR_CHECK(ndr_push_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
20212                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data_length));
20213                         }
20214                         NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data));
20215                 }
20216         }
20217         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
20218         return NDR_ERR_SUCCESS;
20219 }
20220
20221 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
20222 {
20223         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
20224         uint32_t _ptr_value_name;
20225         TALLOC_CTX *_mem_save_value_name_0;
20226         uint32_t _ptr_data;
20227         TALLOC_CTX *_mem_save_data_0;
20228         if (ndr_flags & NDR_SCALARS) {
20229                 NDR_CHECK(ndr_pull_align(ndr, 5));
20230                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
20231                 {
20232                         uint32_t _flags_save_string = ndr->flags;
20233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20234                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
20235                         if (_ptr_value_name) {
20236                                 NDR_PULL_ALLOC(ndr, r->value_name);
20237                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
20238                         } else {
20239                                 r->value_name = NULL;
20240                         }
20241                         ndr->flags = _flags_save_string;
20242                 }
20243                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
20244                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
20245                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
20246                 if (_ptr_data) {
20247                         NDR_PULL_ALLOC(ndr, r->data);
20248                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
20249                 } else {
20250                         r->data = NULL;
20251                 }
20252                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
20253                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
20254         }
20255         if (ndr_flags & NDR_BUFFERS) {
20256                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
20257                 {
20258                         uint32_t _flags_save_string = ndr->flags;
20259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20260                         if (r->value_name) {
20261                                 uint32_t _relative_save_offset;
20262                                 _relative_save_offset = ndr->offset;
20263                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
20264                                 _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
20265                                 NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
20266                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
20267                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
20268                                 if (ndr->offset > ndr->relative_highest_offset) {
20269                                         ndr->relative_highest_offset = ndr->offset;
20270                                 }
20271                                 ndr->offset = _relative_save_offset;
20272                         }
20273                         ndr->flags = _flags_save_string;
20274                 }
20275                 if (r->data) {
20276                         uint32_t _relative_save_offset;
20277                         _relative_save_offset = ndr->offset;
20278                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
20279                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
20280                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
20281                         {
20282                                 struct ndr_pull *_ndr_data;
20283                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
20284                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, r->data, r->type));
20285                                 NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
20286                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
20287                         }
20288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
20289                         if (ndr->offset > ndr->relative_highest_offset) {
20290                                 ndr->relative_highest_offset = ndr->offset;
20291                         }
20292                         ndr->offset = _relative_save_offset;
20293                 }
20294         }
20295         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
20296         return NDR_ERR_SUCCESS;
20297 }
20298
20299 _PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
20300 {
20301         ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
20302         ndr->depth++;
20303         ndr_print_ptr(ndr, "value_name", r->value_name);
20304         ndr->depth++;
20305         if (r->value_name) {
20306                 ndr_print_string(ndr, "value_name", r->value_name);
20307         }
20308         ndr->depth--;
20309         ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
20310         ndr_print_winreg_Type(ndr, "type", r->type);
20311         ndr_print_ptr(ndr, "data", r->data);
20312         ndr->depth++;
20313         if (r->data) {
20314                 ndr_print_set_switch_value(ndr, r->data, r->type);
20315                 ndr_print_spoolss_PrinterData(ndr, "data", r->data);
20316         }
20317         ndr->depth--;
20318         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);
20319         ndr->depth--;
20320 }
20321
20322 _PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
20323 {
20324         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
20325 }
20326
20327 static enum ndr_err_code ndr_push_spoolss_KeyNames(struct ndr_push *ndr, int ndr_flags, const union spoolss_KeyNames *r)
20328 {
20329         if (ndr_flags & NDR_SCALARS) {
20330                 int level = ndr_push_get_switch_value(ndr, r);
20331                 NDR_CHECK(ndr_push_union_align(ndr, 4));
20332                 switch (level) {
20333                         case 0: {
20334                         break; }
20335
20336                         case 1: {
20337                         break; }
20338
20339                         default: {
20340                                 {
20341                                         uint32_t _flags_save_string_array = ndr->flags;
20342                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20343                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
20344                                         ndr->flags = _flags_save_string_array;
20345                                 }
20346                         break; }
20347
20348                 }
20349         }
20350         if (ndr_flags & NDR_BUFFERS) {
20351                 int level = ndr_push_get_switch_value(ndr, r);
20352                 switch (level) {
20353                         case 0:
20354                         break;
20355
20356                         case 1:
20357                         break;
20358
20359                         default:
20360                         break;
20361
20362                 }
20363         }
20364         return NDR_ERR_SUCCESS;
20365 }
20366
20367 static enum ndr_err_code ndr_pull_spoolss_KeyNames(struct ndr_pull *ndr, int ndr_flags, union spoolss_KeyNames *r)
20368 {
20369         int level;
20370         level = ndr_pull_get_switch_value(ndr, r);
20371         if (ndr_flags & NDR_SCALARS) {
20372                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
20373                 switch (level) {
20374                         case 0: {
20375                         break; }
20376
20377                         case 1: {
20378                         break; }
20379
20380                         default: {
20381                                 {
20382                                         uint32_t _flags_save_string_array = ndr->flags;
20383                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20384                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
20385                                         ndr->flags = _flags_save_string_array;
20386                                 }
20387                         break; }
20388
20389                 }
20390         }
20391         if (ndr_flags & NDR_BUFFERS) {
20392                 switch (level) {
20393                         case 0:
20394                         break;
20395
20396                         case 1:
20397                         break;
20398
20399                         default:
20400                         break;
20401
20402                 }
20403         }
20404         return NDR_ERR_SUCCESS;
20405 }
20406
20407 _PUBLIC_ void ndr_print_spoolss_KeyNames(struct ndr_print *ndr, const char *name, const union spoolss_KeyNames *r)
20408 {
20409         int level;
20410         level = ndr_print_get_switch_value(ndr, r);
20411         ndr_print_union(ndr, name, level, "spoolss_KeyNames");
20412         switch (level) {
20413                 case 0:
20414                 break;
20415
20416                 case 1:
20417                 break;
20418
20419                 default:
20420                         ndr_print_string_array(ndr, "string_array", r->string_array);
20421                 break;
20422
20423         }
20424 }
20425
20426 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
20427 {
20428         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
20429         return NDR_ERR_SUCCESS;
20430 }
20431
20432 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
20433 {
20434         uint32_t v;
20435         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
20436         *r = v;
20437         return NDR_ERR_SUCCESS;
20438 }
20439
20440 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
20441 {
20442         ndr_print_uint32(ndr, name, r);
20443         ndr->depth++;
20444         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
20445         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
20446         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
20447         ndr->depth--;
20448 }
20449
20450 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
20451 {
20452         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
20453         return NDR_ERR_SUCCESS;
20454 }
20455
20456 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
20457 {
20458         uint32_t v;
20459         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
20460         *r = v;
20461         return NDR_ERR_SUCCESS;
20462 }
20463
20464 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
20465 {
20466         const char *val = NULL;
20467
20468         switch (r) {
20469                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
20470                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
20471         }
20472         ndr_print_enum(ndr, name, "ENUM", val, r);
20473 }
20474
20475 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
20476 {
20477         if (ndr_flags & NDR_SCALARS) {
20478                 NDR_CHECK(ndr_push_align(ndr, 4));
20479                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
20480                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
20481                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
20482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
20483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
20484                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
20485                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20486                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
20487                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
20488                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
20489                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
20490                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20491                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
20492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
20493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
20494                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20495         }
20496         if (ndr_flags & NDR_BUFFERS) {
20497         }
20498         return NDR_ERR_SUCCESS;
20499 }
20500
20501 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
20502 {
20503         if (ndr_flags & NDR_SCALARS) {
20504                 NDR_CHECK(ndr_pull_align(ndr, 4));
20505                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
20506                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
20507                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
20508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
20509                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
20510                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
20511                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20512                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
20513                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
20514                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
20515                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
20516                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20517                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
20518                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
20519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
20520                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20521         }
20522         if (ndr_flags & NDR_BUFFERS) {
20523         }
20524         return NDR_ERR_SUCCESS;
20525 }
20526
20527 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
20528 {
20529         ndr_print_struct(ndr, name, "spoolss_PortData1");
20530         ndr->depth++;
20531         ndr_print_string(ndr, "portname", r->portname);
20532         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
20533         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
20534         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
20535         ndr_print_uint32(ndr, "reserved", r->reserved);
20536         ndr_print_string(ndr, "hostaddress", r->hostaddress);
20537         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
20538         ndr_print_uint32(ndr, "dblspool", r->dblspool);
20539         ndr_print_string(ndr, "queue", r->queue);
20540         ndr_print_string(ndr, "ip_address", r->ip_address);
20541         ndr_print_string(ndr, "hardware_address", r->hardware_address);
20542         ndr_print_string(ndr, "device_type", r->device_type);
20543         ndr_print_uint32(ndr, "port_number", r->port_number);
20544         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
20545         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
20546         ndr->depth--;
20547 }
20548
20549 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
20550 {
20551         if (ndr_flags & NDR_SCALARS) {
20552                 NDR_CHECK(ndr_push_align(ndr, 4));
20553                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
20554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
20555                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
20556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
20557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
20558                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
20559                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20560                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
20561                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
20562                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
20564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
20565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
20566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
20567                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20568         }
20569         if (ndr_flags & NDR_BUFFERS) {
20570         }
20571         return NDR_ERR_SUCCESS;
20572 }
20573
20574 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
20575 {
20576         if (ndr_flags & NDR_SCALARS) {
20577                 NDR_CHECK(ndr_pull_align(ndr, 4));
20578                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
20579                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
20580                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
20581                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
20582                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
20583                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
20584                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20585                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
20586                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
20587                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20588                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
20589                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
20590                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
20591                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
20592                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20593         }
20594         if (ndr_flags & NDR_BUFFERS) {
20595         }
20596         return NDR_ERR_SUCCESS;
20597 }
20598
20599 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
20600 {
20601         ndr_print_struct(ndr, name, "spoolss_PortData2");
20602         ndr->depth++;
20603         ndr_print_string(ndr, "portname", r->portname);
20604         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
20605         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
20606         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
20607         ndr_print_uint32(ndr, "reserved", r->reserved);
20608         ndr_print_string(ndr, "hostaddress", r->hostaddress);
20609         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
20610         ndr_print_uint32(ndr, "dblspool", r->dblspool);
20611         ndr_print_string(ndr, "queue", r->queue);
20612         ndr_print_string(ndr, "device_type", r->device_type);
20613         ndr_print_uint32(ndr, "port_number", r->port_number);
20614         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
20615         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
20616         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
20617         ndr->depth--;
20618 }
20619
20620 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
20621 {
20622         if (ndr_flags & NDR_SCALARS) {
20623                 NDR_CHECK(ndr_push_align(ndr, 4));
20624                 {
20625                         uint32_t _flags_save_string = ndr->flags;
20626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20627                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
20628                         ndr->flags = _flags_save_string;
20629                 }
20630                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20631         }
20632         if (ndr_flags & NDR_BUFFERS) {
20633         }
20634         return NDR_ERR_SUCCESS;
20635 }
20636
20637 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
20638 {
20639         if (ndr_flags & NDR_SCALARS) {
20640                 NDR_CHECK(ndr_pull_align(ndr, 4));
20641                 {
20642                         uint32_t _flags_save_string = ndr->flags;
20643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20644                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
20645                         ndr->flags = _flags_save_string;
20646                 }
20647                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20648         }
20649         if (ndr_flags & NDR_BUFFERS) {
20650         }
20651         return NDR_ERR_SUCCESS;
20652 }
20653
20654 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
20655 {
20656         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
20657         ndr->depth++;
20658         ndr_print_string(ndr, "dll_name", r->dll_name);
20659         ndr->depth--;
20660 }
20661
20662 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
20663 {
20664         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
20665         return NDR_ERR_SUCCESS;
20666 }
20667
20668 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
20669 {
20670         uint32_t v;
20671         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
20672         *r = v;
20673         return NDR_ERR_SUCCESS;
20674 }
20675
20676 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
20677 {
20678         ndr_print_uint32(ndr, name, r);
20679         ndr->depth++;
20680         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
20681         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
20682         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
20683         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
20684         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
20685         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
20686         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
20687         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
20688         ndr->depth--;
20689 }
20690
20691 static enum ndr_err_code ndr_push_spoolss_CorePrinterDriver(struct ndr_push *ndr, int ndr_flags, const struct spoolss_CorePrinterDriver *r)
20692 {
20693         if (ndr_flags & NDR_SCALARS) {
20694                 NDR_CHECK(ndr_push_align(ndr, 8));
20695                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
20696                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
20697                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
20698                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 520, sizeof(uint8_t), CH_UTF8));
20699                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
20700         }
20701         if (ndr_flags & NDR_BUFFERS) {
20702         }
20703         return NDR_ERR_SUCCESS;
20704 }
20705
20706 static enum ndr_err_code ndr_pull_spoolss_CorePrinterDriver(struct ndr_pull *ndr, int ndr_flags, struct spoolss_CorePrinterDriver *r)
20707 {
20708         if (ndr_flags & NDR_SCALARS) {
20709                 NDR_CHECK(ndr_pull_align(ndr, 8));
20710                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
20711                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
20712                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
20713                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 520, sizeof(uint8_t), CH_UTF8));
20714                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
20715         }
20716         if (ndr_flags & NDR_BUFFERS) {
20717         }
20718         return NDR_ERR_SUCCESS;
20719 }
20720
20721 _PUBLIC_ void ndr_print_spoolss_CorePrinterDriver(struct ndr_print *ndr, const char *name, const struct spoolss_CorePrinterDriver *r)
20722 {
20723         ndr_print_struct(ndr, name, "spoolss_CorePrinterDriver");
20724         ndr->depth++;
20725         ndr_print_GUID(ndr, "core_driver_guid", &r->core_driver_guid);
20726         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
20727         ndr_print_hyper(ndr, "driver_version", r->driver_version);
20728         ndr_print_string(ndr, "formname", r->formname);
20729         ndr->depth--;
20730 }
20731
20732 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
20733 {
20734         if (flags & NDR_IN) {
20735                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
20736                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20737                 if (r->in.server) {
20738                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20739                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20740                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20741                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20742                 }
20743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20744                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20745                 if (r->in.buffer) {
20746                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20747                 }
20748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20749         }
20750         if (flags & NDR_OUT) {
20751                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20752                 if (r->out.info) {
20753                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20754                 }
20755                 if (r->out.needed == NULL) {
20756                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20757                 }
20758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20759                 if (r->out.count == NULL) {
20760                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20761                 }
20762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20763                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20764         }
20765         return NDR_ERR_SUCCESS;
20766 }
20767
20768 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
20769 {
20770         uint32_t _ptr_server;
20771         uint32_t _ptr_buffer;
20772         uint32_t _ptr_info;
20773         TALLOC_CTX *_mem_save_server_0;
20774         TALLOC_CTX *_mem_save_buffer_0;
20775         TALLOC_CTX *_mem_save_info_0;
20776         TALLOC_CTX *_mem_save_needed_0;
20777         TALLOC_CTX *_mem_save_count_0;
20778         if (flags & NDR_IN) {
20779                 ZERO_STRUCT(r->out);
20780
20781                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
20782                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20783                 if (_ptr_server) {
20784                         NDR_PULL_ALLOC(ndr, r->in.server);
20785                 } else {
20786                         r->in.server = NULL;
20787                 }
20788                 if (r->in.server) {
20789                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20790                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20791                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20792                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20793                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20794                                 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));
20795                         }
20796                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20797                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20798                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20799                 }
20800                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20801                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20802                 if (_ptr_buffer) {
20803                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20804                 } else {
20805                         r->in.buffer = NULL;
20806                 }
20807                 if (r->in.buffer) {
20808                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20809                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20810                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20811                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20812                 }
20813                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20814                 NDR_PULL_ALLOC(ndr, r->out.needed);
20815                 ZERO_STRUCTP(r->out.needed);
20816                 NDR_PULL_ALLOC(ndr, r->out.count);
20817                 ZERO_STRUCTP(r->out.count);
20818         }
20819         if (flags & NDR_OUT) {
20820                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20821                 if (_ptr_info) {
20822                         NDR_PULL_ALLOC(ndr, r->out.info);
20823                 } else {
20824                         r->out.info = NULL;
20825                 }
20826                 if (r->out.info) {
20827                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20828                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20829                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20830                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20831                 }
20832                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20833                         NDR_PULL_ALLOC(ndr, r->out.needed);
20834                 }
20835                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20836                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20837                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20838                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20839                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20840                         NDR_PULL_ALLOC(ndr, r->out.count);
20841                 }
20842                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20843                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20844                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20845                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20846                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20847         }
20848         return NDR_ERR_SUCCESS;
20849 }
20850
20851 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
20852 {
20853         uint32_t cntr_info_0;
20854         if (flags & NDR_IN) {
20855                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20856                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20857         }
20858         if (flags & NDR_OUT) {
20859                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20860                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20861                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20862                 }
20863                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20864                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20865                 }
20866         }
20867         return NDR_ERR_SUCCESS;
20868 }
20869
20870 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
20871 {
20872         uint32_t cntr_info_0;
20873         TALLOC_CTX *_mem_save_info_0;
20874         if (flags & NDR_IN) {
20875                 ZERO_STRUCT(r->out);
20876
20877                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20879         }
20880         if (flags & NDR_OUT) {
20881                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20882                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20883                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20884                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20885                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20886                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20887                 }
20888                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20889                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20890                 }
20891                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20892         }
20893         return NDR_ERR_SUCCESS;
20894 }
20895
20896 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
20897 {
20898         uint32_t cntr_info_2;
20899         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
20900         ndr->depth++;
20901         if (flags & NDR_SET_VALUES) {
20902                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20903         }
20904         if (flags & NDR_IN) {
20905                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
20906                 ndr->depth++;
20907                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
20908                 ndr_print_ptr(ndr, "server", r->in.server);
20909                 ndr->depth++;
20910                 if (r->in.server) {
20911                         ndr_print_string(ndr, "server", r->in.server);
20912                 }
20913                 ndr->depth--;
20914                 ndr_print_uint32(ndr, "level", r->in.level);
20915                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20916                 ndr->depth++;
20917                 if (r->in.buffer) {
20918                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20919                 }
20920                 ndr->depth--;
20921                 ndr_print_uint32(ndr, "offered", r->in.offered);
20922                 ndr->depth--;
20923         }
20924         if (flags & NDR_OUT) {
20925                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
20926                 ndr->depth++;
20927                 ndr_print_ptr(ndr, "count", r->out.count);
20928                 ndr->depth++;
20929                 ndr_print_uint32(ndr, "count", *r->out.count);
20930                 ndr->depth--;
20931                 ndr_print_ptr(ndr, "info", r->out.info);
20932                 ndr->depth++;
20933                 ndr_print_ptr(ndr, "info", *r->out.info);
20934                 ndr->depth++;
20935                 if (*r->out.info) {
20936                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20937                         ndr->depth++;
20938                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20939                                 char *idx_2=NULL;
20940                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20941                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20942                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20943                                         free(idx_2);
20944                                 }
20945                         }
20946                         ndr->depth--;
20947                 }
20948                 ndr->depth--;
20949                 ndr->depth--;
20950                 ndr_print_ptr(ndr, "needed", r->out.needed);
20951                 ndr->depth++;
20952                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20953                 ndr->depth--;
20954                 ndr_print_WERROR(ndr, "result", r->out.result);
20955                 ndr->depth--;
20956         }
20957         ndr->depth--;
20958 }
20959
20960 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
20961 {
20962         if (flags & NDR_IN) {
20963                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
20964                 if (r->in.printername) {
20965                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20966                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20967                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20968                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20969                 }
20970                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
20971                 if (r->in.datatype) {
20972                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20973                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20974                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20975                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20976                 }
20977                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20978                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
20979         }
20980         if (flags & NDR_OUT) {
20981                 if (r->out.handle == NULL) {
20982                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20983                 }
20984                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20985                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20986         }
20987         return NDR_ERR_SUCCESS;
20988 }
20989
20990 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
20991 {
20992         uint32_t _ptr_printername;
20993         uint32_t _ptr_datatype;
20994         TALLOC_CTX *_mem_save_printername_0;
20995         TALLOC_CTX *_mem_save_datatype_0;
20996         TALLOC_CTX *_mem_save_handle_0;
20997         if (flags & NDR_IN) {
20998                 ZERO_STRUCT(r->out);
20999
21000                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
21001                 if (_ptr_printername) {
21002                         NDR_PULL_ALLOC(ndr, r->in.printername);
21003                 } else {
21004                         r->in.printername = NULL;
21005                 }
21006                 if (r->in.printername) {
21007                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
21008                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
21009                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
21010                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
21011                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
21012                                 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));
21013                         }
21014                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
21015                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
21016                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
21017                 }
21018                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
21019                 if (_ptr_datatype) {
21020                         NDR_PULL_ALLOC(ndr, r->in.datatype);
21021                 } else {
21022                         r->in.datatype = NULL;
21023                 }
21024                 if (r->in.datatype) {
21025                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
21026                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
21027                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
21028                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
21029                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
21030                                 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));
21031                         }
21032                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
21033                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
21034                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
21035                 }
21036                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
21037                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
21038                 NDR_PULL_ALLOC(ndr, r->out.handle);
21039                 ZERO_STRUCTP(r->out.handle);
21040         }
21041         if (flags & NDR_OUT) {
21042                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21043                         NDR_PULL_ALLOC(ndr, r->out.handle);
21044                 }
21045                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21046                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21047                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21048                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21049                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21050         }
21051         return NDR_ERR_SUCCESS;
21052 }
21053
21054 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
21055 {
21056         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
21057         ndr->depth++;
21058         if (flags & NDR_SET_VALUES) {
21059                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21060         }
21061         if (flags & NDR_IN) {
21062                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
21063                 ndr->depth++;
21064                 ndr_print_ptr(ndr, "printername", r->in.printername);
21065                 ndr->depth++;
21066                 if (r->in.printername) {
21067                         ndr_print_string(ndr, "printername", r->in.printername);
21068                 }
21069                 ndr->depth--;
21070                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
21071                 ndr->depth++;
21072                 if (r->in.datatype) {
21073                         ndr_print_string(ndr, "datatype", r->in.datatype);
21074                 }
21075                 ndr->depth--;
21076                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
21077                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
21078                 ndr->depth--;
21079         }
21080         if (flags & NDR_OUT) {
21081                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
21082                 ndr->depth++;
21083                 ndr_print_ptr(ndr, "handle", r->out.handle);
21084                 ndr->depth++;
21085                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21086                 ndr->depth--;
21087                 ndr_print_WERROR(ndr, "result", r->out.result);
21088                 ndr->depth--;
21089         }
21090         ndr->depth--;
21091 }
21092
21093 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
21094 {
21095         if (flags & NDR_IN) {
21096                 if (r->in.handle == NULL) {
21097                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21098                 }
21099                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
21101                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
21102                 if (r->in.ctr) {
21103                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
21104                 }
21105                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
21106         }
21107         if (flags & NDR_OUT) {
21108                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21109         }
21110         return NDR_ERR_SUCCESS;
21111 }
21112
21113 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
21114 {
21115         uint32_t _ptr_ctr;
21116         TALLOC_CTX *_mem_save_handle_0;
21117         TALLOC_CTX *_mem_save_ctr_0;
21118         if (flags & NDR_IN) {
21119                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21120                         NDR_PULL_ALLOC(ndr, r->in.handle);
21121                 }
21122                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21123                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21124                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21125                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
21127                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
21128                 if (_ptr_ctr) {
21129                         NDR_PULL_ALLOC(ndr, r->in.ctr);
21130                 } else {
21131                         r->in.ctr = NULL;
21132                 }
21133                 if (r->in.ctr) {
21134                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21135                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
21136                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
21137                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
21138                 }
21139                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
21140         }
21141         if (flags & NDR_OUT) {
21142                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21143         }
21144         return NDR_ERR_SUCCESS;
21145 }
21146
21147 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
21148 {
21149         ndr_print_struct(ndr, name, "spoolss_SetJob");
21150         ndr->depth++;
21151         if (flags & NDR_SET_VALUES) {
21152                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21153         }
21154         if (flags & NDR_IN) {
21155                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
21156                 ndr->depth++;
21157                 ndr_print_ptr(ndr, "handle", r->in.handle);
21158                 ndr->depth++;
21159                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21160                 ndr->depth--;
21161                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
21162                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
21163                 ndr->depth++;
21164                 if (r->in.ctr) {
21165                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
21166                 }
21167                 ndr->depth--;
21168                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
21169                 ndr->depth--;
21170         }
21171         if (flags & NDR_OUT) {
21172                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
21173                 ndr->depth++;
21174                 ndr_print_WERROR(ndr, "result", r->out.result);
21175                 ndr->depth--;
21176         }
21177         ndr->depth--;
21178 }
21179
21180 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
21181 {
21182         if (flags & NDR_IN) {
21183                 if (r->in.handle == NULL) {
21184                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21185                 }
21186                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21187                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
21188                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21189                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21190                 if (r->in.buffer) {
21191                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21192                 }
21193                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21194         }
21195         if (flags & NDR_OUT) {
21196                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21197                 if (r->out.info) {
21198                         {
21199                                 struct ndr_push *_ndr_info;
21200                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21201                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21202                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21203                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21204                         }
21205                 }
21206                 if (r->out.needed == NULL) {
21207                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21208                 }
21209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21210                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21211         }
21212         return NDR_ERR_SUCCESS;
21213 }
21214
21215 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
21216 {
21217         uint32_t _ptr_buffer;
21218         uint32_t _ptr_info;
21219         TALLOC_CTX *_mem_save_handle_0;
21220         TALLOC_CTX *_mem_save_buffer_0;
21221         TALLOC_CTX *_mem_save_info_0;
21222         TALLOC_CTX *_mem_save_needed_0;
21223         if (flags & NDR_IN) {
21224                 ZERO_STRUCT(r->out);
21225
21226                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21227                         NDR_PULL_ALLOC(ndr, r->in.handle);
21228                 }
21229                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21230                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21231                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21232                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21233                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
21234                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21235                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21236                 if (_ptr_buffer) {
21237                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21238                 } else {
21239                         r->in.buffer = NULL;
21240                 }
21241                 if (r->in.buffer) {
21242                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21243                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21244                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21245                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21246                 }
21247                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21248                 NDR_PULL_ALLOC(ndr, r->out.needed);
21249                 ZERO_STRUCTP(r->out.needed);
21250         }
21251         if (flags & NDR_OUT) {
21252                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21253                 if (_ptr_info) {
21254                         NDR_PULL_ALLOC(ndr, r->out.info);
21255                 } else {
21256                         r->out.info = NULL;
21257                 }
21258                 if (r->out.info) {
21259                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21260                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21261                         {
21262                                 struct ndr_pull *_ndr_info;
21263                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21264                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21265                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21266                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21267                         }
21268                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21269                 }
21270                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21271                         NDR_PULL_ALLOC(ndr, r->out.needed);
21272                 }
21273                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21274                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21276                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21277                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21278         }
21279         return NDR_ERR_SUCCESS;
21280 }
21281
21282 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
21283 {
21284         ndr_print_struct(ndr, name, "spoolss_GetJob");
21285         ndr->depth++;
21286         if (flags & NDR_SET_VALUES) {
21287                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21288         }
21289         if (flags & NDR_IN) {
21290                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
21291                 ndr->depth++;
21292                 ndr_print_ptr(ndr, "handle", r->in.handle);
21293                 ndr->depth++;
21294                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21295                 ndr->depth--;
21296                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
21297                 ndr_print_uint32(ndr, "level", r->in.level);
21298                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21299                 ndr->depth++;
21300                 if (r->in.buffer) {
21301                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21302                 }
21303                 ndr->depth--;
21304                 ndr_print_uint32(ndr, "offered", r->in.offered);
21305                 ndr->depth--;
21306         }
21307         if (flags & NDR_OUT) {
21308                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
21309                 ndr->depth++;
21310                 ndr_print_ptr(ndr, "info", r->out.info);
21311                 ndr->depth++;
21312                 if (r->out.info) {
21313                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21314                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
21315                 }
21316                 ndr->depth--;
21317                 ndr_print_ptr(ndr, "needed", r->out.needed);
21318                 ndr->depth++;
21319                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21320                 ndr->depth--;
21321                 ndr_print_WERROR(ndr, "result", r->out.result);
21322                 ndr->depth--;
21323         }
21324         ndr->depth--;
21325 }
21326
21327 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
21328 {
21329         if (flags & NDR_IN) {
21330                 if (r->in.handle == NULL) {
21331                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21332                 }
21333                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
21335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
21336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21337                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21338                 if (r->in.buffer) {
21339                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21340                 }
21341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21342         }
21343         if (flags & NDR_OUT) {
21344                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21345                 if (r->out.info) {
21346                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
21347                 }
21348                 if (r->out.needed == NULL) {
21349                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21350                 }
21351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21352                 if (r->out.count == NULL) {
21353                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21354                 }
21355                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21356                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21357         }
21358         return NDR_ERR_SUCCESS;
21359 }
21360
21361 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
21362 {
21363         uint32_t _ptr_buffer;
21364         uint32_t _ptr_info;
21365         TALLOC_CTX *_mem_save_handle_0;
21366         TALLOC_CTX *_mem_save_buffer_0;
21367         TALLOC_CTX *_mem_save_info_0;
21368         TALLOC_CTX *_mem_save_needed_0;
21369         TALLOC_CTX *_mem_save_count_0;
21370         if (flags & NDR_IN) {
21371                 ZERO_STRUCT(r->out);
21372
21373                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21374                         NDR_PULL_ALLOC(ndr, r->in.handle);
21375                 }
21376                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21377                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21378                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21379                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
21381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
21382                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21383                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21384                 if (_ptr_buffer) {
21385                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21386                 } else {
21387                         r->in.buffer = NULL;
21388                 }
21389                 if (r->in.buffer) {
21390                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21391                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21392                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21393                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21394                 }
21395                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21396                 NDR_PULL_ALLOC(ndr, r->out.needed);
21397                 ZERO_STRUCTP(r->out.needed);
21398                 NDR_PULL_ALLOC(ndr, r->out.count);
21399                 ZERO_STRUCTP(r->out.count);
21400         }
21401         if (flags & NDR_OUT) {
21402                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21403                 if (_ptr_info) {
21404                         NDR_PULL_ALLOC(ndr, r->out.info);
21405                 } else {
21406                         r->out.info = NULL;
21407                 }
21408                 if (r->out.info) {
21409                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21410                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21411                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
21412                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21413                 }
21414                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21415                         NDR_PULL_ALLOC(ndr, r->out.needed);
21416                 }
21417                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21418                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21420                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21421                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21422                         NDR_PULL_ALLOC(ndr, r->out.count);
21423                 }
21424                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21425                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21427                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21428                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21429         }
21430         return NDR_ERR_SUCCESS;
21431 }
21432
21433 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
21434 {
21435         uint32_t cntr_info_0;
21436         if (flags & NDR_IN) {
21437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
21439         }
21440         if (flags & NDR_OUT) {
21441                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21442                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21443                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21444                 }
21445                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21446                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21447                 }
21448         }
21449         return NDR_ERR_SUCCESS;
21450 }
21451
21452 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
21453 {
21454         uint32_t cntr_info_0;
21455         TALLOC_CTX *_mem_save_info_0;
21456         if (flags & NDR_IN) {
21457                 ZERO_STRUCT(r->out);
21458
21459                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21461         }
21462         if (flags & NDR_OUT) {
21463                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
21464                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21465                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21466                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21467                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21468                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21469                 }
21470                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21471                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21472                 }
21473                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21474         }
21475         return NDR_ERR_SUCCESS;
21476 }
21477
21478 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
21479 {
21480         uint32_t cntr_info_2;
21481         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
21482         ndr->depth++;
21483         if (flags & NDR_SET_VALUES) {
21484                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21485         }
21486         if (flags & NDR_IN) {
21487                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
21488                 ndr->depth++;
21489                 ndr_print_ptr(ndr, "handle", r->in.handle);
21490                 ndr->depth++;
21491                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21492                 ndr->depth--;
21493                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
21494                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
21495                 ndr_print_uint32(ndr, "level", r->in.level);
21496                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21497                 ndr->depth++;
21498                 if (r->in.buffer) {
21499                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21500                 }
21501                 ndr->depth--;
21502                 ndr_print_uint32(ndr, "offered", r->in.offered);
21503                 ndr->depth--;
21504         }
21505         if (flags & NDR_OUT) {
21506                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
21507                 ndr->depth++;
21508                 ndr_print_ptr(ndr, "count", r->out.count);
21509                 ndr->depth++;
21510                 ndr_print_uint32(ndr, "count", *r->out.count);
21511                 ndr->depth--;
21512                 ndr_print_ptr(ndr, "info", r->out.info);
21513                 ndr->depth++;
21514                 ndr_print_ptr(ndr, "info", *r->out.info);
21515                 ndr->depth++;
21516                 if (*r->out.info) {
21517                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21518                         ndr->depth++;
21519                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21520                                 char *idx_2=NULL;
21521                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21522                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21523                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21524                                         free(idx_2);
21525                                 }
21526                         }
21527                         ndr->depth--;
21528                 }
21529                 ndr->depth--;
21530                 ndr->depth--;
21531                 ndr_print_ptr(ndr, "needed", r->out.needed);
21532                 ndr->depth++;
21533                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21534                 ndr->depth--;
21535                 ndr_print_WERROR(ndr, "result", r->out.result);
21536                 ndr->depth--;
21537         }
21538         ndr->depth--;
21539 }
21540
21541 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
21542 {
21543         if (flags & NDR_IN) {
21544                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21545                 if (r->in.server) {
21546                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21547                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21548                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21549                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21550                 }
21551                 if (r->in.info_ctr == NULL) {
21552                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21553                 }
21554                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21555                 if (r->in.devmode_ctr == NULL) {
21556                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21557                 }
21558                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21559                 if (r->in.secdesc_ctr == NULL) {
21560                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21561                 }
21562                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21563         }
21564         if (flags & NDR_OUT) {
21565                 if (r->out.handle == NULL) {
21566                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21567                 }
21568                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21569                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21570         }
21571         return NDR_ERR_SUCCESS;
21572 }
21573
21574 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
21575 {
21576         uint32_t _ptr_server;
21577         TALLOC_CTX *_mem_save_server_0;
21578         TALLOC_CTX *_mem_save_info_ctr_0;
21579         TALLOC_CTX *_mem_save_devmode_ctr_0;
21580         TALLOC_CTX *_mem_save_secdesc_ctr_0;
21581         TALLOC_CTX *_mem_save_handle_0;
21582         if (flags & NDR_IN) {
21583                 ZERO_STRUCT(r->out);
21584
21585                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21586                 if (_ptr_server) {
21587                         NDR_PULL_ALLOC(ndr, r->in.server);
21588                 } else {
21589                         r->in.server = NULL;
21590                 }
21591                 if (r->in.server) {
21592                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21593                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21594                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21595                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21596                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21597                                 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));
21598                         }
21599                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21600                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21601                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21602                 }
21603                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21604                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21605                 }
21606                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21607                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21608                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21609                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21610                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21611                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21612                 }
21613                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21614                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21615                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21616                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21617                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21618                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21619                 }
21620                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21621                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21622                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21623                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21624                 NDR_PULL_ALLOC(ndr, r->out.handle);
21625                 ZERO_STRUCTP(r->out.handle);
21626         }
21627         if (flags & NDR_OUT) {
21628                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21629                         NDR_PULL_ALLOC(ndr, r->out.handle);
21630                 }
21631                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21632                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21633                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21634                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21635                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21636         }
21637         return NDR_ERR_SUCCESS;
21638 }
21639
21640 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
21641 {
21642         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
21643         ndr->depth++;
21644         if (flags & NDR_SET_VALUES) {
21645                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21646         }
21647         if (flags & NDR_IN) {
21648                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
21649                 ndr->depth++;
21650                 ndr_print_ptr(ndr, "server", r->in.server);
21651                 ndr->depth++;
21652                 if (r->in.server) {
21653                         ndr_print_string(ndr, "server", r->in.server);
21654                 }
21655                 ndr->depth--;
21656                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21657                 ndr->depth++;
21658                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21659                 ndr->depth--;
21660                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21661                 ndr->depth++;
21662                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21663                 ndr->depth--;
21664                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21665                 ndr->depth++;
21666                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21667                 ndr->depth--;
21668                 ndr->depth--;
21669         }
21670         if (flags & NDR_OUT) {
21671                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
21672                 ndr->depth++;
21673                 ndr_print_ptr(ndr, "handle", r->out.handle);
21674                 ndr->depth++;
21675                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21676                 ndr->depth--;
21677                 ndr_print_WERROR(ndr, "result", r->out.result);
21678                 ndr->depth--;
21679         }
21680         ndr->depth--;
21681 }
21682
21683 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
21684 {
21685         if (flags & NDR_IN) {
21686                 if (r->in.handle == NULL) {
21687                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21688                 }
21689                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21690         }
21691         if (flags & NDR_OUT) {
21692                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21693         }
21694         return NDR_ERR_SUCCESS;
21695 }
21696
21697 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
21698 {
21699         TALLOC_CTX *_mem_save_handle_0;
21700         if (flags & NDR_IN) {
21701                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21702                         NDR_PULL_ALLOC(ndr, r->in.handle);
21703                 }
21704                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21705                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21706                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21707                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21708         }
21709         if (flags & NDR_OUT) {
21710                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21711         }
21712         return NDR_ERR_SUCCESS;
21713 }
21714
21715 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
21716 {
21717         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
21718         ndr->depth++;
21719         if (flags & NDR_SET_VALUES) {
21720                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21721         }
21722         if (flags & NDR_IN) {
21723                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
21724                 ndr->depth++;
21725                 ndr_print_ptr(ndr, "handle", r->in.handle);
21726                 ndr->depth++;
21727                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21728                 ndr->depth--;
21729                 ndr->depth--;
21730         }
21731         if (flags & NDR_OUT) {
21732                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
21733                 ndr->depth++;
21734                 ndr_print_WERROR(ndr, "result", r->out.result);
21735                 ndr->depth--;
21736         }
21737         ndr->depth--;
21738 }
21739
21740 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
21741 {
21742         if (flags & NDR_IN) {
21743                 if (r->in.handle == NULL) {
21744                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21745                 }
21746                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21747                 if (r->in.info_ctr == NULL) {
21748                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21749                 }
21750                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21751                 if (r->in.devmode_ctr == NULL) {
21752                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21753                 }
21754                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21755                 if (r->in.secdesc_ctr == NULL) {
21756                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21757                 }
21758                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21759                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
21760         }
21761         if (flags & NDR_OUT) {
21762                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21763         }
21764         return NDR_ERR_SUCCESS;
21765 }
21766
21767 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
21768 {
21769         TALLOC_CTX *_mem_save_handle_0;
21770         TALLOC_CTX *_mem_save_info_ctr_0;
21771         TALLOC_CTX *_mem_save_devmode_ctr_0;
21772         TALLOC_CTX *_mem_save_secdesc_ctr_0;
21773         if (flags & NDR_IN) {
21774                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21775                         NDR_PULL_ALLOC(ndr, r->in.handle);
21776                 }
21777                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21778                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21779                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21780                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21781                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21782                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21783                 }
21784                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21785                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21786                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21787                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21788                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21789                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21790                 }
21791                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21792                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21793                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21794                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21795                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21796                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21797                 }
21798                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21799                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21800                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21801                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21802                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
21803         }
21804         if (flags & NDR_OUT) {
21805                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21806         }
21807         return NDR_ERR_SUCCESS;
21808 }
21809
21810 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
21811 {
21812         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
21813         ndr->depth++;
21814         if (flags & NDR_SET_VALUES) {
21815                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21816         }
21817         if (flags & NDR_IN) {
21818                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
21819                 ndr->depth++;
21820                 ndr_print_ptr(ndr, "handle", r->in.handle);
21821                 ndr->depth++;
21822                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21823                 ndr->depth--;
21824                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21825                 ndr->depth++;
21826                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21827                 ndr->depth--;
21828                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21829                 ndr->depth++;
21830                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21831                 ndr->depth--;
21832                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21833                 ndr->depth++;
21834                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21835                 ndr->depth--;
21836                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
21837                 ndr->depth--;
21838         }
21839         if (flags & NDR_OUT) {
21840                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
21841                 ndr->depth++;
21842                 ndr_print_WERROR(ndr, "result", r->out.result);
21843                 ndr->depth--;
21844         }
21845         ndr->depth--;
21846 }
21847
21848 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
21849 {
21850         if (flags & NDR_IN) {
21851                 if (r->in.handle == NULL) {
21852                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21853                 }
21854                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21855                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21856                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21857                 if (r->in.buffer) {
21858                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21859                 }
21860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21861         }
21862         if (flags & NDR_OUT) {
21863                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21864                 if (r->out.info) {
21865                         {
21866                                 struct ndr_push *_ndr_info;
21867                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21868                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21869                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21870                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21871                         }
21872                 }
21873                 if (r->out.needed == NULL) {
21874                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21875                 }
21876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21877                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21878         }
21879         return NDR_ERR_SUCCESS;
21880 }
21881
21882 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
21883 {
21884         uint32_t _ptr_buffer;
21885         uint32_t _ptr_info;
21886         TALLOC_CTX *_mem_save_handle_0;
21887         TALLOC_CTX *_mem_save_buffer_0;
21888         TALLOC_CTX *_mem_save_info_0;
21889         TALLOC_CTX *_mem_save_needed_0;
21890         if (flags & NDR_IN) {
21891                 ZERO_STRUCT(r->out);
21892
21893                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21894                         NDR_PULL_ALLOC(ndr, r->in.handle);
21895                 }
21896                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21897                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21898                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21899                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21900                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21901                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21902                 if (_ptr_buffer) {
21903                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21904                 } else {
21905                         r->in.buffer = NULL;
21906                 }
21907                 if (r->in.buffer) {
21908                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21909                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21910                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21911                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21912                 }
21913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21914                 NDR_PULL_ALLOC(ndr, r->out.needed);
21915                 ZERO_STRUCTP(r->out.needed);
21916         }
21917         if (flags & NDR_OUT) {
21918                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21919                 if (_ptr_info) {
21920                         NDR_PULL_ALLOC(ndr, r->out.info);
21921                 } else {
21922                         r->out.info = NULL;
21923                 }
21924                 if (r->out.info) {
21925                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21926                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21927                         {
21928                                 struct ndr_pull *_ndr_info;
21929                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21930                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21931                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21932                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21933                         }
21934                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21935                 }
21936                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21937                         NDR_PULL_ALLOC(ndr, r->out.needed);
21938                 }
21939                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21940                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21941                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21942                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21943                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21944         }
21945         return NDR_ERR_SUCCESS;
21946 }
21947
21948 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
21949 {
21950         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
21951         ndr->depth++;
21952         if (flags & NDR_SET_VALUES) {
21953                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21954         }
21955         if (flags & NDR_IN) {
21956                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
21957                 ndr->depth++;
21958                 ndr_print_ptr(ndr, "handle", r->in.handle);
21959                 ndr->depth++;
21960                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21961                 ndr->depth--;
21962                 ndr_print_uint32(ndr, "level", r->in.level);
21963                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21964                 ndr->depth++;
21965                 if (r->in.buffer) {
21966                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21967                 }
21968                 ndr->depth--;
21969                 ndr_print_uint32(ndr, "offered", r->in.offered);
21970                 ndr->depth--;
21971         }
21972         if (flags & NDR_OUT) {
21973                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
21974                 ndr->depth++;
21975                 ndr_print_ptr(ndr, "info", r->out.info);
21976                 ndr->depth++;
21977                 if (r->out.info) {
21978                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21979                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
21980                 }
21981                 ndr->depth--;
21982                 ndr_print_ptr(ndr, "needed", r->out.needed);
21983                 ndr->depth++;
21984                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21985                 ndr->depth--;
21986                 ndr_print_WERROR(ndr, "result", r->out.result);
21987                 ndr->depth--;
21988         }
21989         ndr->depth--;
21990 }
21991
21992 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
21993 {
21994         if (flags & NDR_IN) {
21995                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
21996                 if (r->in.servername) {
21997                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21998                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21999                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22000                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22001                 }
22002                 if (r->in.info_ctr == NULL) {
22003                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22004                 }
22005                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
22006         }
22007         if (flags & NDR_OUT) {
22008                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22009         }
22010         return NDR_ERR_SUCCESS;
22011 }
22012
22013 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
22014 {
22015         uint32_t _ptr_servername;
22016         TALLOC_CTX *_mem_save_servername_0;
22017         TALLOC_CTX *_mem_save_info_ctr_0;
22018         if (flags & NDR_IN) {
22019                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22020                 if (_ptr_servername) {
22021                         NDR_PULL_ALLOC(ndr, r->in.servername);
22022                 } else {
22023                         r->in.servername = NULL;
22024                 }
22025                 if (r->in.servername) {
22026                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22027                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22028                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22029                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22030                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22031                                 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));
22032                         }
22033                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22034                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22035                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22036                 }
22037                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22038                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
22039                 }
22040                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
22041                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
22042                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
22043                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
22044         }
22045         if (flags & NDR_OUT) {
22046                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22047         }
22048         return NDR_ERR_SUCCESS;
22049 }
22050
22051 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
22052 {
22053         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
22054         ndr->depth++;
22055         if (flags & NDR_SET_VALUES) {
22056                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22057         }
22058         if (flags & NDR_IN) {
22059                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
22060                 ndr->depth++;
22061                 ndr_print_ptr(ndr, "servername", r->in.servername);
22062                 ndr->depth++;
22063                 if (r->in.servername) {
22064                         ndr_print_string(ndr, "servername", r->in.servername);
22065                 }
22066                 ndr->depth--;
22067                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
22068                 ndr->depth++;
22069                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
22070                 ndr->depth--;
22071                 ndr->depth--;
22072         }
22073         if (flags & NDR_OUT) {
22074                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
22075                 ndr->depth++;
22076                 ndr_print_WERROR(ndr, "result", r->out.result);
22077                 ndr->depth--;
22078         }
22079         ndr->depth--;
22080 }
22081
22082 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
22083 {
22084         if (flags & NDR_IN) {
22085                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22086                 if (r->in.server) {
22087                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22088                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22089                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22090                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22091                 }
22092                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22093                 if (r->in.environment) {
22094                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22095                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22096                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22097                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22098                 }
22099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22100                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22101                 if (r->in.buffer) {
22102                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22103                 }
22104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22105         }
22106         if (flags & NDR_OUT) {
22107                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22108                 if (r->out.info) {
22109                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22110                 }
22111                 if (r->out.needed == NULL) {
22112                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22113                 }
22114                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22115                 if (r->out.count == NULL) {
22116                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22117                 }
22118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22119                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22120         }
22121         return NDR_ERR_SUCCESS;
22122 }
22123
22124 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
22125 {
22126         uint32_t _ptr_server;
22127         uint32_t _ptr_environment;
22128         uint32_t _ptr_buffer;
22129         uint32_t _ptr_info;
22130         TALLOC_CTX *_mem_save_server_0;
22131         TALLOC_CTX *_mem_save_environment_0;
22132         TALLOC_CTX *_mem_save_buffer_0;
22133         TALLOC_CTX *_mem_save_info_0;
22134         TALLOC_CTX *_mem_save_needed_0;
22135         TALLOC_CTX *_mem_save_count_0;
22136         if (flags & NDR_IN) {
22137                 ZERO_STRUCT(r->out);
22138
22139                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22140                 if (_ptr_server) {
22141                         NDR_PULL_ALLOC(ndr, r->in.server);
22142                 } else {
22143                         r->in.server = NULL;
22144                 }
22145                 if (r->in.server) {
22146                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22147                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22148                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22149                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22150                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22151                                 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));
22152                         }
22153                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22154                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22155                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22156                 }
22157                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22158                 if (_ptr_environment) {
22159                         NDR_PULL_ALLOC(ndr, r->in.environment);
22160                 } else {
22161                         r->in.environment = NULL;
22162                 }
22163                 if (r->in.environment) {
22164                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22165                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22166                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22167                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22168                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22169                                 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));
22170                         }
22171                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22172                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22173                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22174                 }
22175                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22176                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22177                 if (_ptr_buffer) {
22178                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22179                 } else {
22180                         r->in.buffer = NULL;
22181                 }
22182                 if (r->in.buffer) {
22183                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22184                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22185                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22186                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22187                 }
22188                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22189                 NDR_PULL_ALLOC(ndr, r->out.needed);
22190                 ZERO_STRUCTP(r->out.needed);
22191                 NDR_PULL_ALLOC(ndr, r->out.count);
22192                 ZERO_STRUCTP(r->out.count);
22193         }
22194         if (flags & NDR_OUT) {
22195                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22196                 if (_ptr_info) {
22197                         NDR_PULL_ALLOC(ndr, r->out.info);
22198                 } else {
22199                         r->out.info = NULL;
22200                 }
22201                 if (r->out.info) {
22202                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22203                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22204                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22205                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22206                 }
22207                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22208                         NDR_PULL_ALLOC(ndr, r->out.needed);
22209                 }
22210                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22211                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22212                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22213                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22214                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22215                         NDR_PULL_ALLOC(ndr, r->out.count);
22216                 }
22217                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22218                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22219                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22220                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22221                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22222         }
22223         return NDR_ERR_SUCCESS;
22224 }
22225
22226 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
22227 {
22228         uint32_t cntr_info_0;
22229         if (flags & NDR_IN) {
22230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22231                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22232         }
22233         if (flags & NDR_OUT) {
22234                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22235                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22236                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22237                 }
22238                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22239                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22240                 }
22241         }
22242         return NDR_ERR_SUCCESS;
22243 }
22244
22245 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
22246 {
22247         uint32_t cntr_info_0;
22248         TALLOC_CTX *_mem_save_info_0;
22249         if (flags & NDR_IN) {
22250                 ZERO_STRUCT(r->out);
22251
22252                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22253                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22254         }
22255         if (flags & NDR_OUT) {
22256                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22257                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22258                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22259                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22260                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22261                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22262                 }
22263                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22264                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22265                 }
22266                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22267         }
22268         return NDR_ERR_SUCCESS;
22269 }
22270
22271 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
22272 {
22273         uint32_t cntr_info_2;
22274         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
22275         ndr->depth++;
22276         if (flags & NDR_SET_VALUES) {
22277                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22278         }
22279         if (flags & NDR_IN) {
22280                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
22281                 ndr->depth++;
22282                 ndr_print_ptr(ndr, "server", r->in.server);
22283                 ndr->depth++;
22284                 if (r->in.server) {
22285                         ndr_print_string(ndr, "server", r->in.server);
22286                 }
22287                 ndr->depth--;
22288                 ndr_print_ptr(ndr, "environment", r->in.environment);
22289                 ndr->depth++;
22290                 if (r->in.environment) {
22291                         ndr_print_string(ndr, "environment", r->in.environment);
22292                 }
22293                 ndr->depth--;
22294                 ndr_print_uint32(ndr, "level", r->in.level);
22295                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22296                 ndr->depth++;
22297                 if (r->in.buffer) {
22298                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22299                 }
22300                 ndr->depth--;
22301                 ndr_print_uint32(ndr, "offered", r->in.offered);
22302                 ndr->depth--;
22303         }
22304         if (flags & NDR_OUT) {
22305                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
22306                 ndr->depth++;
22307                 ndr_print_ptr(ndr, "count", r->out.count);
22308                 ndr->depth++;
22309                 ndr_print_uint32(ndr, "count", *r->out.count);
22310                 ndr->depth--;
22311                 ndr_print_ptr(ndr, "info", r->out.info);
22312                 ndr->depth++;
22313                 ndr_print_ptr(ndr, "info", *r->out.info);
22314                 ndr->depth++;
22315                 if (*r->out.info) {
22316                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22317                         ndr->depth++;
22318                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22319                                 char *idx_2=NULL;
22320                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22321                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22322                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22323                                         free(idx_2);
22324                                 }
22325                         }
22326                         ndr->depth--;
22327                 }
22328                 ndr->depth--;
22329                 ndr->depth--;
22330                 ndr_print_ptr(ndr, "needed", r->out.needed);
22331                 ndr->depth++;
22332                 ndr_print_uint32(ndr, "needed", *r->out.needed);
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_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *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                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
22348                 if (r->in.architecture) {
22349                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22350                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22351                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22352                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22353                 }
22354                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22355                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22356                 if (r->in.buffer) {
22357                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22358                 }
22359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22360         }
22361         if (flags & NDR_OUT) {
22362                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22363                 if (r->out.info) {
22364                         {
22365                                 struct ndr_push *_ndr_info;
22366                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22367                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22368                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22369                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22370                         }
22371                 }
22372                 if (r->out.needed == NULL) {
22373                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22374                 }
22375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22376                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22377         }
22378         return NDR_ERR_SUCCESS;
22379 }
22380
22381 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
22382 {
22383         uint32_t _ptr_architecture;
22384         uint32_t _ptr_buffer;
22385         uint32_t _ptr_info;
22386         TALLOC_CTX *_mem_save_handle_0;
22387         TALLOC_CTX *_mem_save_architecture_0;
22388         TALLOC_CTX *_mem_save_buffer_0;
22389         TALLOC_CTX *_mem_save_info_0;
22390         TALLOC_CTX *_mem_save_needed_0;
22391         if (flags & NDR_IN) {
22392                 ZERO_STRUCT(r->out);
22393
22394                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22395                         NDR_PULL_ALLOC(ndr, r->in.handle);
22396                 }
22397                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22398                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22399                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22400                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22401                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
22402                 if (_ptr_architecture) {
22403                         NDR_PULL_ALLOC(ndr, r->in.architecture);
22404                 } else {
22405                         r->in.architecture = NULL;
22406                 }
22407                 if (r->in.architecture) {
22408                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
22409                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
22410                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22411                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22412                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22413                                 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));
22414                         }
22415                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22416                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22417                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
22418                 }
22419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22420                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22421                 if (_ptr_buffer) {
22422                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22423                 } else {
22424                         r->in.buffer = NULL;
22425                 }
22426                 if (r->in.buffer) {
22427                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22428                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22429                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22430                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22431                 }
22432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22433                 NDR_PULL_ALLOC(ndr, r->out.needed);
22434                 ZERO_STRUCTP(r->out.needed);
22435         }
22436         if (flags & NDR_OUT) {
22437                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22438                 if (_ptr_info) {
22439                         NDR_PULL_ALLOC(ndr, r->out.info);
22440                 } else {
22441                         r->out.info = NULL;
22442                 }
22443                 if (r->out.info) {
22444                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22445                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22446                         {
22447                                 struct ndr_pull *_ndr_info;
22448                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22449                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22450                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22451                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22452                         }
22453                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22454                 }
22455                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22456                         NDR_PULL_ALLOC(ndr, r->out.needed);
22457                 }
22458                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22459                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22461                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22462                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22463         }
22464         return NDR_ERR_SUCCESS;
22465 }
22466
22467 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
22468 {
22469         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
22470         ndr->depth++;
22471         if (flags & NDR_SET_VALUES) {
22472                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22473         }
22474         if (flags & NDR_IN) {
22475                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
22476                 ndr->depth++;
22477                 ndr_print_ptr(ndr, "handle", r->in.handle);
22478                 ndr->depth++;
22479                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22480                 ndr->depth--;
22481                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
22482                 ndr->depth++;
22483                 if (r->in.architecture) {
22484                         ndr_print_string(ndr, "architecture", r->in.architecture);
22485                 }
22486                 ndr->depth--;
22487                 ndr_print_uint32(ndr, "level", r->in.level);
22488                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22489                 ndr->depth++;
22490                 if (r->in.buffer) {
22491                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22492                 }
22493                 ndr->depth--;
22494                 ndr_print_uint32(ndr, "offered", r->in.offered);
22495                 ndr->depth--;
22496         }
22497         if (flags & NDR_OUT) {
22498                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
22499                 ndr->depth++;
22500                 ndr_print_ptr(ndr, "info", r->out.info);
22501                 ndr->depth++;
22502                 if (r->out.info) {
22503                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22504                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
22505                 }
22506                 ndr->depth--;
22507                 ndr_print_ptr(ndr, "needed", r->out.needed);
22508                 ndr->depth++;
22509                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22510                 ndr->depth--;
22511                 ndr_print_WERROR(ndr, "result", r->out.result);
22512                 ndr->depth--;
22513         }
22514         ndr->depth--;
22515 }
22516
22517 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
22518 {
22519         if (flags & NDR_IN) {
22520                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22521                 if (r->in.server) {
22522                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22523                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22524                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22525                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22526                 }
22527                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22528                 if (r->in.environment) {
22529                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22530                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22531                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22532                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22533                 }
22534                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22535                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22536                 if (r->in.buffer) {
22537                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22538                 }
22539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22540         }
22541         if (flags & NDR_OUT) {
22542                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22543                 if (r->out.info) {
22544                         {
22545                                 struct ndr_push *_ndr_info;
22546                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22547                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22548                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22549                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22550                         }
22551                 }
22552                 if (r->out.needed == NULL) {
22553                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22554                 }
22555                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22556                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22557         }
22558         return NDR_ERR_SUCCESS;
22559 }
22560
22561 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
22562 {
22563         uint32_t _ptr_server;
22564         uint32_t _ptr_environment;
22565         uint32_t _ptr_buffer;
22566         uint32_t _ptr_info;
22567         TALLOC_CTX *_mem_save_server_0;
22568         TALLOC_CTX *_mem_save_environment_0;
22569         TALLOC_CTX *_mem_save_buffer_0;
22570         TALLOC_CTX *_mem_save_info_0;
22571         TALLOC_CTX *_mem_save_needed_0;
22572         if (flags & NDR_IN) {
22573                 ZERO_STRUCT(r->out);
22574
22575                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22576                 if (_ptr_server) {
22577                         NDR_PULL_ALLOC(ndr, r->in.server);
22578                 } else {
22579                         r->in.server = NULL;
22580                 }
22581                 if (r->in.server) {
22582                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22583                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22584                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22585                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22586                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22587                                 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));
22588                         }
22589                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22590                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22591                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22592                 }
22593                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22594                 if (_ptr_environment) {
22595                         NDR_PULL_ALLOC(ndr, r->in.environment);
22596                 } else {
22597                         r->in.environment = NULL;
22598                 }
22599                 if (r->in.environment) {
22600                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22601                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22602                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22603                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22604                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22605                                 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));
22606                         }
22607                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22608                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22609                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22610                 }
22611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22612                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22613                 if (_ptr_buffer) {
22614                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22615                 } else {
22616                         r->in.buffer = NULL;
22617                 }
22618                 if (r->in.buffer) {
22619                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22620                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22621                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22622                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22623                 }
22624                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22625                 NDR_PULL_ALLOC(ndr, r->out.needed);
22626                 ZERO_STRUCTP(r->out.needed);
22627         }
22628         if (flags & NDR_OUT) {
22629                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22630                 if (_ptr_info) {
22631                         NDR_PULL_ALLOC(ndr, r->out.info);
22632                 } else {
22633                         r->out.info = NULL;
22634                 }
22635                 if (r->out.info) {
22636                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22637                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22638                         {
22639                                 struct ndr_pull *_ndr_info;
22640                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22641                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22642                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22643                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22644                         }
22645                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22646                 }
22647                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22648                         NDR_PULL_ALLOC(ndr, r->out.needed);
22649                 }
22650                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22651                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22653                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22654                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22655         }
22656         return NDR_ERR_SUCCESS;
22657 }
22658
22659 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
22660 {
22661         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
22662         ndr->depth++;
22663         if (flags & NDR_SET_VALUES) {
22664                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22665         }
22666         if (flags & NDR_IN) {
22667                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
22668                 ndr->depth++;
22669                 ndr_print_ptr(ndr, "server", r->in.server);
22670                 ndr->depth++;
22671                 if (r->in.server) {
22672                         ndr_print_string(ndr, "server", r->in.server);
22673                 }
22674                 ndr->depth--;
22675                 ndr_print_ptr(ndr, "environment", r->in.environment);
22676                 ndr->depth++;
22677                 if (r->in.environment) {
22678                         ndr_print_string(ndr, "environment", r->in.environment);
22679                 }
22680                 ndr->depth--;
22681                 ndr_print_uint32(ndr, "level", r->in.level);
22682                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22683                 ndr->depth++;
22684                 if (r->in.buffer) {
22685                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22686                 }
22687                 ndr->depth--;
22688                 ndr_print_uint32(ndr, "offered", r->in.offered);
22689                 ndr->depth--;
22690         }
22691         if (flags & NDR_OUT) {
22692                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
22693                 ndr->depth++;
22694                 ndr_print_ptr(ndr, "info", r->out.info);
22695                 ndr->depth++;
22696                 if (r->out.info) {
22697                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22698                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
22699                 }
22700                 ndr->depth--;
22701                 ndr_print_ptr(ndr, "needed", r->out.needed);
22702                 ndr->depth++;
22703                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22704                 ndr->depth--;
22705                 ndr_print_WERROR(ndr, "result", r->out.result);
22706                 ndr->depth--;
22707         }
22708         ndr->depth--;
22709 }
22710
22711 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
22712 {
22713         if (flags & NDR_IN) {
22714                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22715                 if (r->in.server) {
22716                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22717                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22718                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22719                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22720                 }
22721                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22722                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22723                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22724                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22725                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22726                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22727                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22728                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22729         }
22730         if (flags & NDR_OUT) {
22731                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22732         }
22733         return NDR_ERR_SUCCESS;
22734 }
22735
22736 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
22737 {
22738         uint32_t _ptr_server;
22739         TALLOC_CTX *_mem_save_server_0;
22740         if (flags & NDR_IN) {
22741                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22742                 if (_ptr_server) {
22743                         NDR_PULL_ALLOC(ndr, r->in.server);
22744                 } else {
22745                         r->in.server = NULL;
22746                 }
22747                 if (r->in.server) {
22748                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22749                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22750                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22751                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22752                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22753                                 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));
22754                         }
22755                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22756                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22757                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22758                 }
22759                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22760                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22761                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22762                         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));
22763                 }
22764                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22765                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22766                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
22767                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
22768                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
22769                         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));
22770                 }
22771                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
22772                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
22773         }
22774         if (flags & NDR_OUT) {
22775                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22776         }
22777         return NDR_ERR_SUCCESS;
22778 }
22779
22780 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
22781 {
22782         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
22783         ndr->depth++;
22784         if (flags & NDR_SET_VALUES) {
22785                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22786         }
22787         if (flags & NDR_IN) {
22788                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
22789                 ndr->depth++;
22790                 ndr_print_ptr(ndr, "server", r->in.server);
22791                 ndr->depth++;
22792                 if (r->in.server) {
22793                         ndr_print_string(ndr, "server", r->in.server);
22794                 }
22795                 ndr->depth--;
22796                 ndr_print_string(ndr, "architecture", r->in.architecture);
22797                 ndr_print_string(ndr, "driver", r->in.driver);
22798                 ndr->depth--;
22799         }
22800         if (flags & NDR_OUT) {
22801                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
22802                 ndr->depth++;
22803                 ndr_print_WERROR(ndr, "result", r->out.result);
22804                 ndr->depth--;
22805         }
22806         ndr->depth--;
22807 }
22808
22809 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
22810 {
22811         if (flags & NDR_IN) {
22812                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22813                 if (r->in.server) {
22814                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22815                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22816                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22817                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22818                 }
22819                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22820                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22821                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22822                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22823                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22824                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22825                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22826                 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));
22827                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22828                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22829                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22830                 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));
22831         }
22832         if (flags & NDR_OUT) {
22833                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22834         }
22835         return NDR_ERR_SUCCESS;
22836 }
22837
22838 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
22839 {
22840         uint32_t _ptr_server;
22841         TALLOC_CTX *_mem_save_server_0;
22842         if (flags & NDR_IN) {
22843                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22844                 if (_ptr_server) {
22845                         NDR_PULL_ALLOC(ndr, r->in.server);
22846                 } else {
22847                         r->in.server = NULL;
22848                 }
22849                 if (r->in.server) {
22850                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22851                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22852                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22853                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22854                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22855                                 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));
22856                         }
22857                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22858                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22859                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22860                 }
22861                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22862                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22863                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22864                         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));
22865                 }
22866                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22867                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22868                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
22869                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
22870                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
22871                         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));
22872                 }
22873                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
22874                 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));
22875                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
22876                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
22877                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
22878                         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));
22879                 }
22880                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
22881                 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));
22882         }
22883         if (flags & NDR_OUT) {
22884                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22885         }
22886         return NDR_ERR_SUCCESS;
22887 }
22888
22889 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
22890 {
22891         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
22892         ndr->depth++;
22893         if (flags & NDR_SET_VALUES) {
22894                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22895         }
22896         if (flags & NDR_IN) {
22897                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
22898                 ndr->depth++;
22899                 ndr_print_ptr(ndr, "server", r->in.server);
22900                 ndr->depth++;
22901                 if (r->in.server) {
22902                         ndr_print_string(ndr, "server", r->in.server);
22903                 }
22904                 ndr->depth--;
22905                 ndr_print_string(ndr, "architecture", r->in.architecture);
22906                 ndr_print_string(ndr, "path_name", r->in.path_name);
22907                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
22908                 ndr->depth--;
22909         }
22910         if (flags & NDR_OUT) {
22911                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
22912                 ndr->depth++;
22913                 ndr_print_WERROR(ndr, "result", r->out.result);
22914                 ndr->depth--;
22915         }
22916         ndr->depth--;
22917 }
22918
22919 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
22920 {
22921         if (flags & NDR_IN) {
22922                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22923                 if (r->in.servername) {
22924                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22925                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22926                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22927                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22928                 }
22929                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22930                 if (r->in.environment) {
22931                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22932                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22933                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22934                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22935                 }
22936                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22937                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22938                 if (r->in.buffer) {
22939                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22940                 }
22941                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22942         }
22943         if (flags & NDR_OUT) {
22944                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22945                 if (r->out.info) {
22946                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22947                 }
22948                 if (r->out.needed == NULL) {
22949                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22950                 }
22951                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22952                 if (r->out.count == NULL) {
22953                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22954                 }
22955                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22956                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22957         }
22958         return NDR_ERR_SUCCESS;
22959 }
22960
22961 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
22962 {
22963         uint32_t _ptr_servername;
22964         uint32_t _ptr_environment;
22965         uint32_t _ptr_buffer;
22966         uint32_t _ptr_info;
22967         TALLOC_CTX *_mem_save_servername_0;
22968         TALLOC_CTX *_mem_save_environment_0;
22969         TALLOC_CTX *_mem_save_buffer_0;
22970         TALLOC_CTX *_mem_save_info_0;
22971         TALLOC_CTX *_mem_save_needed_0;
22972         TALLOC_CTX *_mem_save_count_0;
22973         if (flags & NDR_IN) {
22974                 ZERO_STRUCT(r->out);
22975
22976                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22977                 if (_ptr_servername) {
22978                         NDR_PULL_ALLOC(ndr, r->in.servername);
22979                 } else {
22980                         r->in.servername = NULL;
22981                 }
22982                 if (r->in.servername) {
22983                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22984                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22985                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22986                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22987                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22988                                 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));
22989                         }
22990                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22991                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22992                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22993                 }
22994                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22995                 if (_ptr_environment) {
22996                         NDR_PULL_ALLOC(ndr, r->in.environment);
22997                 } else {
22998                         r->in.environment = NULL;
22999                 }
23000                 if (r->in.environment) {
23001                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
23002                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
23003                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
23004                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
23005                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
23006                                 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));
23007                         }
23008                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
23009                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
23010                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
23011                 }
23012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23013                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23014                 if (_ptr_buffer) {
23015                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23016                 } else {
23017                         r->in.buffer = NULL;
23018                 }
23019                 if (r->in.buffer) {
23020                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23021                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23022                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23023                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23024                 }
23025                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23026                 NDR_PULL_ALLOC(ndr, r->out.needed);
23027                 ZERO_STRUCTP(r->out.needed);
23028                 NDR_PULL_ALLOC(ndr, r->out.count);
23029                 ZERO_STRUCTP(r->out.count);
23030         }
23031         if (flags & NDR_OUT) {
23032                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23033                 if (_ptr_info) {
23034                         NDR_PULL_ALLOC(ndr, r->out.info);
23035                 } else {
23036                         r->out.info = NULL;
23037                 }
23038                 if (r->out.info) {
23039                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23040                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23041                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23042                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23043                 }
23044                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23045                         NDR_PULL_ALLOC(ndr, r->out.needed);
23046                 }
23047                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23048                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23049                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23050                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23051                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23052                         NDR_PULL_ALLOC(ndr, r->out.count);
23053                 }
23054                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23055                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23057                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23058                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23059         }
23060         return NDR_ERR_SUCCESS;
23061 }
23062
23063 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
23064 {
23065         uint32_t cntr_info_0;
23066         if (flags & NDR_IN) {
23067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23068                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23069         }
23070         if (flags & NDR_OUT) {
23071                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23072                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23073                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23074                 }
23075                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23076                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23077                 }
23078         }
23079         return NDR_ERR_SUCCESS;
23080 }
23081
23082 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
23083 {
23084         uint32_t cntr_info_0;
23085         TALLOC_CTX *_mem_save_info_0;
23086         if (flags & NDR_IN) {
23087                 ZERO_STRUCT(r->out);
23088
23089                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23091         }
23092         if (flags & NDR_OUT) {
23093                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23094                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23095                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23096                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23097                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23098                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23099                 }
23100                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23101                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23102                 }
23103                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23104         }
23105         return NDR_ERR_SUCCESS;
23106 }
23107
23108 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
23109 {
23110         uint32_t cntr_info_2;
23111         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
23112         ndr->depth++;
23113         if (flags & NDR_SET_VALUES) {
23114                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23115         }
23116         if (flags & NDR_IN) {
23117                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
23118                 ndr->depth++;
23119                 ndr_print_ptr(ndr, "servername", r->in.servername);
23120                 ndr->depth++;
23121                 if (r->in.servername) {
23122                         ndr_print_string(ndr, "servername", r->in.servername);
23123                 }
23124                 ndr->depth--;
23125                 ndr_print_ptr(ndr, "environment", r->in.environment);
23126                 ndr->depth++;
23127                 if (r->in.environment) {
23128                         ndr_print_string(ndr, "environment", r->in.environment);
23129                 }
23130                 ndr->depth--;
23131                 ndr_print_uint32(ndr, "level", r->in.level);
23132                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23133                 ndr->depth++;
23134                 if (r->in.buffer) {
23135                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23136                 }
23137                 ndr->depth--;
23138                 ndr_print_uint32(ndr, "offered", r->in.offered);
23139                 ndr->depth--;
23140         }
23141         if (flags & NDR_OUT) {
23142                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
23143                 ndr->depth++;
23144                 ndr_print_ptr(ndr, "count", r->out.count);
23145                 ndr->depth++;
23146                 ndr_print_uint32(ndr, "count", *r->out.count);
23147                 ndr->depth--;
23148                 ndr_print_ptr(ndr, "info", r->out.info);
23149                 ndr->depth++;
23150                 ndr_print_ptr(ndr, "info", *r->out.info);
23151                 ndr->depth++;
23152                 if (*r->out.info) {
23153                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23154                         ndr->depth++;
23155                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23156                                 char *idx_2=NULL;
23157                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23158                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23159                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23160                                         free(idx_2);
23161                                 }
23162                         }
23163                         ndr->depth--;
23164                 }
23165                 ndr->depth--;
23166                 ndr->depth--;
23167                 ndr_print_ptr(ndr, "needed", r->out.needed);
23168                 ndr->depth++;
23169                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23170                 ndr->depth--;
23171                 ndr_print_WERROR(ndr, "result", r->out.result);
23172                 ndr->depth--;
23173         }
23174         ndr->depth--;
23175 }
23176
23177 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
23178 {
23179         if (flags & NDR_IN) {
23180                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
23181                 if (r->in.server) {
23182                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
23183                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23184                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
23185                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23186                 }
23187                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
23188                 if (r->in.environment) {
23189                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
23190                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23191                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
23192                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23193                 }
23194                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23195                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23196                 if (r->in.buffer) {
23197                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23198                 }
23199                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23200         }
23201         if (flags & NDR_OUT) {
23202                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23203                 if (r->out.info) {
23204                         {
23205                                 struct ndr_push *_ndr_info;
23206                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23207                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
23208                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
23209                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23210                         }
23211                 }
23212                 if (r->out.needed == NULL) {
23213                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23214                 }
23215                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23216                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23217         }
23218         return NDR_ERR_SUCCESS;
23219 }
23220
23221 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
23222 {
23223         uint32_t _ptr_server;
23224         uint32_t _ptr_environment;
23225         uint32_t _ptr_buffer;
23226         uint32_t _ptr_info;
23227         TALLOC_CTX *_mem_save_server_0;
23228         TALLOC_CTX *_mem_save_environment_0;
23229         TALLOC_CTX *_mem_save_buffer_0;
23230         TALLOC_CTX *_mem_save_info_0;
23231         TALLOC_CTX *_mem_save_needed_0;
23232         if (flags & NDR_IN) {
23233                 ZERO_STRUCT(r->out);
23234
23235                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
23236                 if (_ptr_server) {
23237                         NDR_PULL_ALLOC(ndr, r->in.server);
23238                 } else {
23239                         r->in.server = NULL;
23240                 }
23241                 if (r->in.server) {
23242                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
23243                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
23244                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
23245                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
23246                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
23247                                 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));
23248                         }
23249                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
23250                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
23251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
23252                 }
23253                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
23254                 if (_ptr_environment) {
23255                         NDR_PULL_ALLOC(ndr, r->in.environment);
23256                 } else {
23257                         r->in.environment = NULL;
23258                 }
23259                 if (r->in.environment) {
23260                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
23261                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
23262                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
23263                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
23264                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
23265                                 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));
23266                         }
23267                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
23268                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
23269                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
23270                 }
23271                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23272                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23273                 if (_ptr_buffer) {
23274                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23275                 } else {
23276                         r->in.buffer = NULL;
23277                 }
23278                 if (r->in.buffer) {
23279                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23280                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23281                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23282                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23283                 }
23284                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23285                 NDR_PULL_ALLOC(ndr, r->out.needed);
23286                 ZERO_STRUCTP(r->out.needed);
23287         }
23288         if (flags & NDR_OUT) {
23289                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23290                 if (_ptr_info) {
23291                         NDR_PULL_ALLOC(ndr, r->out.info);
23292                 } else {
23293                         r->out.info = NULL;
23294                 }
23295                 if (r->out.info) {
23296                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23297                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23298                         {
23299                                 struct ndr_pull *_ndr_info;
23300                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23301                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
23302                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
23303                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23304                         }
23305                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23306                 }
23307                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23308                         NDR_PULL_ALLOC(ndr, r->out.needed);
23309                 }
23310                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23311                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23312                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23313                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23314                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23315         }
23316         return NDR_ERR_SUCCESS;
23317 }
23318
23319 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
23320 {
23321         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
23322         ndr->depth++;
23323         if (flags & NDR_SET_VALUES) {
23324                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23325         }
23326         if (flags & NDR_IN) {
23327                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
23328                 ndr->depth++;
23329                 ndr_print_ptr(ndr, "server", r->in.server);
23330                 ndr->depth++;
23331                 if (r->in.server) {
23332                         ndr_print_string(ndr, "server", r->in.server);
23333                 }
23334                 ndr->depth--;
23335                 ndr_print_ptr(ndr, "environment", r->in.environment);
23336                 ndr->depth++;
23337                 if (r->in.environment) {
23338                         ndr_print_string(ndr, "environment", r->in.environment);
23339                 }
23340                 ndr->depth--;
23341                 ndr_print_uint32(ndr, "level", r->in.level);
23342                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23343                 ndr->depth++;
23344                 if (r->in.buffer) {
23345                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23346                 }
23347                 ndr->depth--;
23348                 ndr_print_uint32(ndr, "offered", r->in.offered);
23349                 ndr->depth--;
23350         }
23351         if (flags & NDR_OUT) {
23352                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
23353                 ndr->depth++;
23354                 ndr_print_ptr(ndr, "info", r->out.info);
23355                 ndr->depth++;
23356                 if (r->out.info) {
23357                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
23358                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
23359                 }
23360                 ndr->depth--;
23361                 ndr_print_ptr(ndr, "needed", r->out.needed);
23362                 ndr->depth++;
23363                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23364                 ndr->depth--;
23365                 ndr_print_WERROR(ndr, "result", r->out.result);
23366                 ndr->depth--;
23367         }
23368         ndr->depth--;
23369 }
23370
23371 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
23372 {
23373         if (flags & NDR_IN) {
23374                 if (r->in.handle == NULL) {
23375                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23376                 }
23377                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23378                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23379                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
23380                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23381         }
23382         if (flags & NDR_OUT) {
23383                 if (r->out.job_id == NULL) {
23384                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23385                 }
23386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
23387                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23388         }
23389         return NDR_ERR_SUCCESS;
23390 }
23391
23392 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
23393 {
23394         TALLOC_CTX *_mem_save_handle_0;
23395         TALLOC_CTX *_mem_save_job_id_0;
23396         if (flags & NDR_IN) {
23397                 ZERO_STRUCT(r->out);
23398
23399                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23400                         NDR_PULL_ALLOC(ndr, r->in.handle);
23401                 }
23402                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23403                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23404                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23405                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23407                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23408                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23409                 NDR_PULL_ALLOC(ndr, r->out.job_id);
23410                 ZERO_STRUCTP(r->out.job_id);
23411         }
23412         if (flags & NDR_OUT) {
23413                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23414                         NDR_PULL_ALLOC(ndr, r->out.job_id);
23415                 }
23416                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
23417                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
23418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
23419                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
23420                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23421         }
23422         return NDR_ERR_SUCCESS;
23423 }
23424
23425 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
23426 {
23427         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
23428         ndr->depth++;
23429         if (flags & NDR_SET_VALUES) {
23430                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23431         }
23432         if (flags & NDR_IN) {
23433                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
23434                 ndr->depth++;
23435                 ndr_print_ptr(ndr, "handle", r->in.handle);
23436                 ndr->depth++;
23437                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23438                 ndr->depth--;
23439                 ndr_print_uint32(ndr, "level", r->in.level);
23440                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
23441                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
23442                 ndr->depth--;
23443         }
23444         if (flags & NDR_OUT) {
23445                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
23446                 ndr->depth++;
23447                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
23448                 ndr->depth++;
23449                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
23450                 ndr->depth--;
23451                 ndr_print_WERROR(ndr, "result", r->out.result);
23452                 ndr->depth--;
23453         }
23454         ndr->depth--;
23455 }
23456
23457 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
23458 {
23459         if (flags & NDR_IN) {
23460                 if (r->in.handle == NULL) {
23461                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23462                 }
23463                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23464         }
23465         if (flags & NDR_OUT) {
23466                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23467         }
23468         return NDR_ERR_SUCCESS;
23469 }
23470
23471 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
23472 {
23473         TALLOC_CTX *_mem_save_handle_0;
23474         if (flags & NDR_IN) {
23475                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23476                         NDR_PULL_ALLOC(ndr, r->in.handle);
23477                 }
23478                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23479                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23480                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23481                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23482         }
23483         if (flags & NDR_OUT) {
23484                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23485         }
23486         return NDR_ERR_SUCCESS;
23487 }
23488
23489 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
23490 {
23491         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
23492         ndr->depth++;
23493         if (flags & NDR_SET_VALUES) {
23494                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23495         }
23496         if (flags & NDR_IN) {
23497                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
23498                 ndr->depth++;
23499                 ndr_print_ptr(ndr, "handle", r->in.handle);
23500                 ndr->depth++;
23501                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23502                 ndr->depth--;
23503                 ndr->depth--;
23504         }
23505         if (flags & NDR_OUT) {
23506                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
23507                 ndr->depth++;
23508                 ndr_print_WERROR(ndr, "result", r->out.result);
23509                 ndr->depth--;
23510         }
23511         ndr->depth--;
23512 }
23513
23514 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
23515 {
23516         if (flags & NDR_IN) {
23517                 if (r->in.handle == NULL) {
23518                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23519                 }
23520                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23521                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
23522                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
23523         }
23524         if (flags & NDR_OUT) {
23525                 if (r->out.num_written == NULL) {
23526                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23527                 }
23528                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
23529                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23530         }
23531         return NDR_ERR_SUCCESS;
23532 }
23533
23534 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
23535 {
23536         TALLOC_CTX *_mem_save_handle_0;
23537         TALLOC_CTX *_mem_save_num_written_0;
23538         if (flags & NDR_IN) {
23539                 ZERO_STRUCT(r->out);
23540
23541                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23542                         NDR_PULL_ALLOC(ndr, r->in.handle);
23543                 }
23544                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23545                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23546                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23547                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23548                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
23549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
23550                 NDR_PULL_ALLOC(ndr, r->out.num_written);
23551                 ZERO_STRUCTP(r->out.num_written);
23552         }
23553         if (flags & NDR_OUT) {
23554                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23555                         NDR_PULL_ALLOC(ndr, r->out.num_written);
23556                 }
23557                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
23558                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
23559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
23560                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
23561                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23562         }
23563         return NDR_ERR_SUCCESS;
23564 }
23565
23566 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
23567 {
23568         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
23569         ndr->depth++;
23570         if (flags & NDR_SET_VALUES) {
23571                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23572         }
23573         if (flags & NDR_IN) {
23574                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
23575                 ndr->depth++;
23576                 ndr_print_ptr(ndr, "handle", r->in.handle);
23577                 ndr->depth++;
23578                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23579                 ndr->depth--;
23580                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
23581                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
23582                 ndr->depth--;
23583         }
23584         if (flags & NDR_OUT) {
23585                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
23586                 ndr->depth++;
23587                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
23588                 ndr->depth++;
23589                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
23590                 ndr->depth--;
23591                 ndr_print_WERROR(ndr, "result", r->out.result);
23592                 ndr->depth--;
23593         }
23594         ndr->depth--;
23595 }
23596
23597 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
23598 {
23599         if (flags & NDR_IN) {
23600                 if (r->in.handle == NULL) {
23601                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23602                 }
23603                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23604         }
23605         if (flags & NDR_OUT) {
23606                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23607         }
23608         return NDR_ERR_SUCCESS;
23609 }
23610
23611 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
23612 {
23613         TALLOC_CTX *_mem_save_handle_0;
23614         if (flags & NDR_IN) {
23615                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23616                         NDR_PULL_ALLOC(ndr, r->in.handle);
23617                 }
23618                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23619                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23620                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23621                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23622         }
23623         if (flags & NDR_OUT) {
23624                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23625         }
23626         return NDR_ERR_SUCCESS;
23627 }
23628
23629 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
23630 {
23631         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
23632         ndr->depth++;
23633         if (flags & NDR_SET_VALUES) {
23634                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23635         }
23636         if (flags & NDR_IN) {
23637                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
23638                 ndr->depth++;
23639                 ndr_print_ptr(ndr, "handle", r->in.handle);
23640                 ndr->depth++;
23641                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23642                 ndr->depth--;
23643                 ndr->depth--;
23644         }
23645         if (flags & NDR_OUT) {
23646                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
23647                 ndr->depth++;
23648                 ndr_print_WERROR(ndr, "result", r->out.result);
23649                 ndr->depth--;
23650         }
23651         ndr->depth--;
23652 }
23653
23654 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
23655 {
23656         if (flags & NDR_IN) {
23657                 if (r->in.handle == NULL) {
23658                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23659                 }
23660                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23661         }
23662         if (flags & NDR_OUT) {
23663                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23664         }
23665         return NDR_ERR_SUCCESS;
23666 }
23667
23668 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
23669 {
23670         TALLOC_CTX *_mem_save_handle_0;
23671         if (flags & NDR_IN) {
23672                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23673                         NDR_PULL_ALLOC(ndr, r->in.handle);
23674                 }
23675                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23676                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23677                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23678                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23679         }
23680         if (flags & NDR_OUT) {
23681                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23682         }
23683         return NDR_ERR_SUCCESS;
23684 }
23685
23686 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
23687 {
23688         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
23689         ndr->depth++;
23690         if (flags & NDR_SET_VALUES) {
23691                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23692         }
23693         if (flags & NDR_IN) {
23694                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
23695                 ndr->depth++;
23696                 ndr_print_ptr(ndr, "handle", r->in.handle);
23697                 ndr->depth++;
23698                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23699                 ndr->depth--;
23700                 ndr->depth--;
23701         }
23702         if (flags & NDR_OUT) {
23703                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
23704                 ndr->depth++;
23705                 ndr_print_WERROR(ndr, "result", r->out.result);
23706                 ndr->depth--;
23707         }
23708         ndr->depth--;
23709 }
23710
23711 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
23712 {
23713         if (flags & NDR_IN) {
23714                 if (r->in.handle == NULL) {
23715                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23716                 }
23717                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
23719         }
23720         if (flags & NDR_OUT) {
23721                 if (r->out.data == NULL) {
23722                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23723                 }
23724                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_size));
23725                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
23726                 if (r->out._data_size == NULL) {
23727                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23728                 }
23729                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
23730                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23731         }
23732         return NDR_ERR_SUCCESS;
23733 }
23734
23735 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
23736 {
23737         TALLOC_CTX *_mem_save_handle_0;
23738         TALLOC_CTX *_mem_save__data_size_0;
23739         if (flags & NDR_IN) {
23740                 ZERO_STRUCT(r->out);
23741
23742                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23743                         NDR_PULL_ALLOC(ndr, r->in.handle);
23744                 }
23745                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23746                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23747                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23748                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23749                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
23750                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
23751                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
23752                 NDR_PULL_ALLOC(ndr, r->out._data_size);
23753                 ZERO_STRUCTP(r->out._data_size);
23754         }
23755         if (flags & NDR_OUT) {
23756                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
23757                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23758                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
23759                 }
23760                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
23761                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23762                         NDR_PULL_ALLOC(ndr, r->out._data_size);
23763                 }
23764                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
23765                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
23766                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
23767                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
23768                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23769                 if (r->out.data) {
23770                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
23771                 }
23772         }
23773         return NDR_ERR_SUCCESS;
23774 }
23775
23776 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
23777 {
23778         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
23779         ndr->depth++;
23780         if (flags & NDR_SET_VALUES) {
23781                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23782         }
23783         if (flags & NDR_IN) {
23784                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
23785                 ndr->depth++;
23786                 ndr_print_ptr(ndr, "handle", r->in.handle);
23787                 ndr->depth++;
23788                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23789                 ndr->depth--;
23790                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
23791                 ndr->depth--;
23792         }
23793         if (flags & NDR_OUT) {
23794                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
23795                 ndr->depth++;
23796                 ndr_print_ptr(ndr, "data", r->out.data);
23797                 ndr->depth++;
23798                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
23799                 ndr->depth--;
23800                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
23801                 ndr->depth++;
23802                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
23803                 ndr->depth--;
23804                 ndr_print_WERROR(ndr, "result", r->out.result);
23805                 ndr->depth--;
23806         }
23807         ndr->depth--;
23808 }
23809
23810 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
23811 {
23812         if (flags & NDR_IN) {
23813                 if (r->in.handle == NULL) {
23814                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23815                 }
23816                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23817         }
23818         if (flags & NDR_OUT) {
23819                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23820         }
23821         return NDR_ERR_SUCCESS;
23822 }
23823
23824 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
23825 {
23826         TALLOC_CTX *_mem_save_handle_0;
23827         if (flags & NDR_IN) {
23828                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23829                         NDR_PULL_ALLOC(ndr, r->in.handle);
23830                 }
23831                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23832                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23833                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23834                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23835         }
23836         if (flags & NDR_OUT) {
23837                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23838         }
23839         return NDR_ERR_SUCCESS;
23840 }
23841
23842 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
23843 {
23844         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
23845         ndr->depth++;
23846         if (flags & NDR_SET_VALUES) {
23847                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23848         }
23849         if (flags & NDR_IN) {
23850                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
23851                 ndr->depth++;
23852                 ndr_print_ptr(ndr, "handle", r->in.handle);
23853                 ndr->depth++;
23854                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23855                 ndr->depth--;
23856                 ndr->depth--;
23857         }
23858         if (flags & NDR_OUT) {
23859                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
23860                 ndr->depth++;
23861                 ndr_print_WERROR(ndr, "result", r->out.result);
23862                 ndr->depth--;
23863         }
23864         ndr->depth--;
23865 }
23866
23867 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
23868 {
23869         if (flags & NDR_IN) {
23870                 if (r->in.handle == NULL) {
23871                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23872                 }
23873                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23875                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23876                 if (r->in.buffer) {
23877                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23878                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
23879                 }
23880                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23881         }
23882         if (flags & NDR_OUT) {
23883                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
23884                 if (r->out.buffer) {
23885                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23886                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
23887                 }
23888                 if (r->out.needed == NULL) {
23889                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23890                 }
23891                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23892                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23893         }
23894         return NDR_ERR_SUCCESS;
23895 }
23896
23897 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
23898 {
23899         uint32_t _ptr_buffer;
23900         TALLOC_CTX *_mem_save_handle_0;
23901         TALLOC_CTX *_mem_save_buffer_0;
23902         TALLOC_CTX *_mem_save_needed_0;
23903         if (flags & NDR_IN) {
23904                 ZERO_STRUCT(r->out);
23905
23906                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23907                         NDR_PULL_ALLOC(ndr, r->in.handle);
23908                 }
23909                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23910                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23911                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23912                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23914                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23915                 if (_ptr_buffer) {
23916                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23917                 } else {
23918                         r->in.buffer = NULL;
23919                 }
23920                 if (r->in.buffer) {
23921                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23922                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23923                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
23924                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
23925                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
23926                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23927                 }
23928                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23929                 NDR_PULL_ALLOC(ndr, r->out.needed);
23930                 ZERO_STRUCTP(r->out.needed);
23931                 if (r->in.buffer) {
23932                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
23933                 }
23934         }
23935         if (flags & NDR_OUT) {
23936                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23937                 if (_ptr_buffer) {
23938                         NDR_PULL_ALLOC(ndr, r->out.buffer);
23939                 } else {
23940                         r->out.buffer = NULL;
23941                 }
23942                 if (r->out.buffer) {
23943                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23944                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
23945                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
23946                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
23947                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
23948                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23949                 }
23950                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23951                         NDR_PULL_ALLOC(ndr, r->out.needed);
23952                 }
23953                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23954                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23955                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23956                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23957                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23958                 if (r->out.buffer) {
23959                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
23960                 }
23961         }
23962         return NDR_ERR_SUCCESS;
23963 }
23964
23965 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
23966 {
23967         ndr_print_struct(ndr, name, "spoolss_AddJob");
23968         ndr->depth++;
23969         if (flags & NDR_SET_VALUES) {
23970                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23971         }
23972         if (flags & NDR_IN) {
23973                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
23974                 ndr->depth++;
23975                 ndr_print_ptr(ndr, "handle", r->in.handle);
23976                 ndr->depth++;
23977                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23978                 ndr->depth--;
23979                 ndr_print_uint32(ndr, "level", r->in.level);
23980                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23981                 ndr->depth++;
23982                 if (r->in.buffer) {
23983                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
23984                 }
23985                 ndr->depth--;
23986                 ndr_print_uint32(ndr, "offered", r->in.offered);
23987                 ndr->depth--;
23988         }
23989         if (flags & NDR_OUT) {
23990                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
23991                 ndr->depth++;
23992                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
23993                 ndr->depth++;
23994                 if (r->out.buffer) {
23995                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
23996                 }
23997                 ndr->depth--;
23998                 ndr_print_ptr(ndr, "needed", r->out.needed);
23999                 ndr->depth++;
24000                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24001                 ndr->depth--;
24002                 ndr_print_WERROR(ndr, "result", r->out.result);
24003                 ndr->depth--;
24004         }
24005         ndr->depth--;
24006 }
24007
24008 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
24009 {
24010         if (flags & NDR_IN) {
24011                 if (r->in.handle == NULL) {
24012                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24013                 }
24014                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24015                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
24016         }
24017         if (flags & NDR_OUT) {
24018                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24019         }
24020         return NDR_ERR_SUCCESS;
24021 }
24022
24023 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
24024 {
24025         TALLOC_CTX *_mem_save_handle_0;
24026         if (flags & NDR_IN) {
24027                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24028                         NDR_PULL_ALLOC(ndr, r->in.handle);
24029                 }
24030                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24031                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24032                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24033                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24034                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
24035         }
24036         if (flags & NDR_OUT) {
24037                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24038         }
24039         return NDR_ERR_SUCCESS;
24040 }
24041
24042 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
24043 {
24044         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
24045         ndr->depth++;
24046         if (flags & NDR_SET_VALUES) {
24047                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24048         }
24049         if (flags & NDR_IN) {
24050                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
24051                 ndr->depth++;
24052                 ndr_print_ptr(ndr, "handle", r->in.handle);
24053                 ndr->depth++;
24054                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24055                 ndr->depth--;
24056                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
24057                 ndr->depth--;
24058         }
24059         if (flags & NDR_OUT) {
24060                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
24061                 ndr->depth++;
24062                 ndr_print_WERROR(ndr, "result", r->out.result);
24063                 ndr->depth--;
24064         }
24065         ndr->depth--;
24066 }
24067
24068 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
24069 {
24070         if (flags & NDR_IN) {
24071                 if (r->in.handle == NULL) {
24072                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24073                 }
24074                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24075                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
24076                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24077                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
24078                 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));
24079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24080         }
24081         if (flags & NDR_OUT) {
24082                 if (r->out.type == NULL) {
24083                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24084                 }
24085                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
24086                 if (r->out.data == NULL) {
24087                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24088                 }
24089                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
24090                 if (r->out.needed == NULL) {
24091                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24092                 }
24093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24094                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24095         }
24096         return NDR_ERR_SUCCESS;
24097 }
24098
24099 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
24100 {
24101         TALLOC_CTX *_mem_save_handle_0;
24102         TALLOC_CTX *_mem_save_type_0;
24103         TALLOC_CTX *_mem_save_data_0;
24104         TALLOC_CTX *_mem_save_needed_0;
24105         if (flags & NDR_IN) {
24106                 ZERO_STRUCT(r->out);
24107
24108                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24109                         NDR_PULL_ALLOC(ndr, r->in.handle);
24110                 }
24111                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24112                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24113                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24114                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24115                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
24116                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
24117                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
24118                         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));
24119                 }
24120                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
24121                 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));
24122                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24123                 NDR_PULL_ALLOC(ndr, r->out.type);
24124                 ZERO_STRUCTP(r->out.type);
24125                 NDR_PULL_ALLOC(ndr, r->out.data);
24126                 ZERO_STRUCTP(r->out.data);
24127                 NDR_PULL_ALLOC(ndr, r->out.needed);
24128                 ZERO_STRUCTP(r->out.needed);
24129         }
24130         if (flags & NDR_OUT) {
24131                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24132                         NDR_PULL_ALLOC(ndr, r->out.type);
24133                 }
24134                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
24135                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
24136                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
24137                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
24138                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24139                         NDR_PULL_ALLOC(ndr, r->out.data);
24140                 }
24141                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
24142                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
24143                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
24144                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
24145                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24146                         NDR_PULL_ALLOC(ndr, r->out.needed);
24147                 }
24148                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24149                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24151                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24152                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24153         }
24154         return NDR_ERR_SUCCESS;
24155 }
24156
24157 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
24158 {
24159         if (flags & NDR_IN) {
24160                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
24161         }
24162         if (flags & NDR_OUT) {
24163                 if (r->out.data == NULL) {
24164                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24165                 }
24166                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
24167                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
24168         }
24169         return NDR_ERR_SUCCESS;
24170 }
24171
24172 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
24173 {
24174         TALLOC_CTX *_mem_save_data_0;
24175         if (flags & NDR_IN) {
24176                 ZERO_STRUCT(r->out);
24177
24178                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
24179                 NDR_PULL_ALLOC(ndr, r->out.data);
24180                 ZERO_STRUCTP(r->out.data);
24181         }
24182         if (flags & NDR_OUT) {
24183                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24184                         NDR_PULL_ALLOC(ndr, r->out.data);
24185                 }
24186                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
24187                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
24188                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
24189                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
24190                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
24191         }
24192         return NDR_ERR_SUCCESS;
24193 }
24194
24195 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
24196 {
24197         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
24198         ndr->depth++;
24199         if (flags & NDR_SET_VALUES) {
24200                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24201         }
24202         if (flags & NDR_IN) {
24203                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
24204                 ndr->depth++;
24205                 ndr_print_ptr(ndr, "handle", r->in.handle);
24206                 ndr->depth++;
24207                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24208                 ndr->depth--;
24209                 ndr_print_string(ndr, "value_name", r->in.value_name);
24210                 ndr_print_uint32(ndr, "offered", r->in.offered);
24211                 ndr->depth--;
24212         }
24213         if (flags & NDR_OUT) {
24214                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
24215                 ndr->depth++;
24216                 ndr_print_ptr(ndr, "type", r->out.type);
24217                 ndr->depth++;
24218                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
24219                 ndr->depth--;
24220                 ndr_print_ptr(ndr, "data", r->out.data);
24221                 ndr->depth++;
24222                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
24223                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
24224                 ndr->depth--;
24225                 ndr_print_ptr(ndr, "needed", r->out.needed);
24226                 ndr->depth++;
24227                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24228                 ndr->depth--;
24229                 ndr_print_WERROR(ndr, "result", r->out.result);
24230                 ndr->depth--;
24231         }
24232         ndr->depth--;
24233 }
24234
24235 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
24236 {
24237         if (flags & NDR_IN) {
24238                 if (r->in.handle == NULL) {
24239                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24240                 }
24241                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24242                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
24243                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24244                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
24245                 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));
24246                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
24247                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
24248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
24249         }
24250         if (flags & NDR_OUT) {
24251                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24252         }
24253         return NDR_ERR_SUCCESS;
24254 }
24255
24256 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
24257 {
24258         if (flags & NDR_IN) {
24259                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
24260         }
24261         if (flags & NDR_OUT) {
24262                 if (r->out.data == NULL) {
24263                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24264                 }
24265                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
24266                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
24267         }
24268         return NDR_ERR_SUCCESS;
24269 }
24270
24271 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
24272 {
24273         TALLOC_CTX *_mem_save_handle_0;
24274         if (flags & NDR_IN) {
24275                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24276                         NDR_PULL_ALLOC(ndr, r->in.handle);
24277                 }
24278                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24279                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24280                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24281                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24282                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
24283                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
24284                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
24285                         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));
24286                 }
24287                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
24288                 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));
24289                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
24290                 {
24291                         struct ndr_pull *_ndr_data;
24292                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
24293                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
24294                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
24295                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
24296                 }
24297                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
24298         }
24299         if (flags & NDR_OUT) {
24300                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24301         }
24302         return NDR_ERR_SUCCESS;
24303 }
24304
24305 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
24306 {
24307         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
24308         ndr->depth++;
24309         if (flags & NDR_SET_VALUES) {
24310                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24311         }
24312         if (flags & NDR_IN) {
24313                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
24314                 ndr->depth++;
24315                 ndr_print_ptr(ndr, "handle", r->in.handle);
24316                 ndr->depth++;
24317                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24318                 ndr->depth--;
24319                 ndr_print_string(ndr, "value_name", r->in.value_name);
24320                 ndr_print_winreg_Type(ndr, "type", r->in.type);
24321                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
24322                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
24323                 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);
24324                 ndr->depth--;
24325         }
24326         if (flags & NDR_OUT) {
24327                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
24328                 ndr->depth++;
24329                 ndr_print_WERROR(ndr, "result", r->out.result);
24330                 ndr->depth--;
24331         }
24332         ndr->depth--;
24333 }
24334
24335 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
24336 {
24337         if (flags & NDR_IN) {
24338         }
24339         if (flags & NDR_OUT) {
24340                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24341         }
24342         return NDR_ERR_SUCCESS;
24343 }
24344
24345 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
24346 {
24347         if (flags & NDR_IN) {
24348         }
24349         if (flags & NDR_OUT) {
24350                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24351         }
24352         return NDR_ERR_SUCCESS;
24353 }
24354
24355 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
24356 {
24357         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
24358         ndr->depth++;
24359         if (flags & NDR_SET_VALUES) {
24360                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24361         }
24362         if (flags & NDR_IN) {
24363                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
24364                 ndr->depth++;
24365                 ndr->depth--;
24366         }
24367         if (flags & NDR_OUT) {
24368                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
24369                 ndr->depth++;
24370                 ndr_print_WERROR(ndr, "result", r->out.result);
24371                 ndr->depth--;
24372         }
24373         ndr->depth--;
24374 }
24375
24376 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
24377 {
24378         if (flags & NDR_IN) {
24379                 if (r->in.handle == NULL) {
24380                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24381                 }
24382                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24383         }
24384         if (flags & NDR_OUT) {
24385                 if (r->out.handle == NULL) {
24386                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24387                 }
24388                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24389                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24390         }
24391         return NDR_ERR_SUCCESS;
24392 }
24393
24394 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
24395 {
24396         TALLOC_CTX *_mem_save_handle_0;
24397         if (flags & NDR_IN) {
24398                 ZERO_STRUCT(r->out);
24399
24400                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24401                         NDR_PULL_ALLOC(ndr, r->in.handle);
24402                 }
24403                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24404                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24405                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24406                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24407                 NDR_PULL_ALLOC(ndr, r->out.handle);
24408                 *r->out.handle = *r->in.handle;
24409         }
24410         if (flags & NDR_OUT) {
24411                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24412                         NDR_PULL_ALLOC(ndr, r->out.handle);
24413                 }
24414                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24415                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24416                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24417                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24418                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24419         }
24420         return NDR_ERR_SUCCESS;
24421 }
24422
24423 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
24424 {
24425         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
24426         ndr->depth++;
24427         if (flags & NDR_SET_VALUES) {
24428                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24429         }
24430         if (flags & NDR_IN) {
24431                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
24432                 ndr->depth++;
24433                 ndr_print_ptr(ndr, "handle", r->in.handle);
24434                 ndr->depth++;
24435                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24436                 ndr->depth--;
24437                 ndr->depth--;
24438         }
24439         if (flags & NDR_OUT) {
24440                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
24441                 ndr->depth++;
24442                 ndr_print_ptr(ndr, "handle", r->out.handle);
24443                 ndr->depth++;
24444                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24445                 ndr->depth--;
24446                 ndr_print_WERROR(ndr, "result", r->out.result);
24447                 ndr->depth--;
24448         }
24449         ndr->depth--;
24450 }
24451
24452 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
24453 {
24454         if (flags & NDR_IN) {
24455                 if (r->in.handle == NULL) {
24456                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24457                 }
24458                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24460                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
24461                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24462         }
24463         if (flags & NDR_OUT) {
24464                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24465         }
24466         return NDR_ERR_SUCCESS;
24467 }
24468
24469 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
24470 {
24471         TALLOC_CTX *_mem_save_handle_0;
24472         if (flags & NDR_IN) {
24473                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24474                         NDR_PULL_ALLOC(ndr, r->in.handle);
24475                 }
24476                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24477                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24478                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24479                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24480                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24481                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
24482                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24483         }
24484         if (flags & NDR_OUT) {
24485                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24486         }
24487         return NDR_ERR_SUCCESS;
24488 }
24489
24490 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
24491 {
24492         ndr_print_struct(ndr, name, "spoolss_AddForm");
24493         ndr->depth++;
24494         if (flags & NDR_SET_VALUES) {
24495                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24496         }
24497         if (flags & NDR_IN) {
24498                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
24499                 ndr->depth++;
24500                 ndr_print_ptr(ndr, "handle", r->in.handle);
24501                 ndr->depth++;
24502                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24503                 ndr->depth--;
24504                 ndr_print_uint32(ndr, "level", r->in.level);
24505                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
24506                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
24507                 ndr->depth--;
24508         }
24509         if (flags & NDR_OUT) {
24510                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
24511                 ndr->depth++;
24512                 ndr_print_WERROR(ndr, "result", r->out.result);
24513                 ndr->depth--;
24514         }
24515         ndr->depth--;
24516 }
24517
24518 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
24519 {
24520         if (flags & NDR_IN) {
24521                 if (r->in.handle == NULL) {
24522                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24523                 }
24524                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24525                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24526                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24527                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24528                 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));
24529         }
24530         if (flags & NDR_OUT) {
24531                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24532         }
24533         return NDR_ERR_SUCCESS;
24534 }
24535
24536 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
24537 {
24538         TALLOC_CTX *_mem_save_handle_0;
24539         if (flags & NDR_IN) {
24540                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24541                         NDR_PULL_ALLOC(ndr, r->in.handle);
24542                 }
24543                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24544                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24545                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24546                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24547                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24548                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24549                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24550                         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));
24551                 }
24552                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24553                 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));
24554         }
24555         if (flags & NDR_OUT) {
24556                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24557         }
24558         return NDR_ERR_SUCCESS;
24559 }
24560
24561 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
24562 {
24563         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
24564         ndr->depth++;
24565         if (flags & NDR_SET_VALUES) {
24566                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24567         }
24568         if (flags & NDR_IN) {
24569                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
24570                 ndr->depth++;
24571                 ndr_print_ptr(ndr, "handle", r->in.handle);
24572                 ndr->depth++;
24573                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24574                 ndr->depth--;
24575                 ndr_print_string(ndr, "form_name", r->in.form_name);
24576                 ndr->depth--;
24577         }
24578         if (flags & NDR_OUT) {
24579                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
24580                 ndr->depth++;
24581                 ndr_print_WERROR(ndr, "result", r->out.result);
24582                 ndr->depth--;
24583         }
24584         ndr->depth--;
24585 }
24586
24587 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
24588 {
24589         if (flags & NDR_IN) {
24590                 if (r->in.handle == NULL) {
24591                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24592                 }
24593                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24594                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24595                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24596                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24597                 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));
24598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24599                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24600                 if (r->in.buffer) {
24601                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24602                 }
24603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24604         }
24605         if (flags & NDR_OUT) {
24606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24607                 if (r->out.info) {
24608                         {
24609                                 struct ndr_push *_ndr_info;
24610                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24611                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
24612                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24613                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24614                         }
24615                 }
24616                 if (r->out.needed == NULL) {
24617                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24618                 }
24619                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24620                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24621         }
24622         return NDR_ERR_SUCCESS;
24623 }
24624
24625 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
24626 {
24627         uint32_t _ptr_buffer;
24628         uint32_t _ptr_info;
24629         TALLOC_CTX *_mem_save_handle_0;
24630         TALLOC_CTX *_mem_save_buffer_0;
24631         TALLOC_CTX *_mem_save_info_0;
24632         TALLOC_CTX *_mem_save_needed_0;
24633         if (flags & NDR_IN) {
24634                 ZERO_STRUCT(r->out);
24635
24636                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24637                         NDR_PULL_ALLOC(ndr, r->in.handle);
24638                 }
24639                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24640                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24641                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24642                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24643                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24644                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24645                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24646                         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));
24647                 }
24648                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24649                 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));
24650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24651                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24652                 if (_ptr_buffer) {
24653                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24654                 } else {
24655                         r->in.buffer = NULL;
24656                 }
24657                 if (r->in.buffer) {
24658                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24659                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24660                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24661                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24662                 }
24663                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24664                 NDR_PULL_ALLOC(ndr, r->out.needed);
24665                 ZERO_STRUCTP(r->out.needed);
24666         }
24667         if (flags & NDR_OUT) {
24668                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24669                 if (_ptr_info) {
24670                         NDR_PULL_ALLOC(ndr, r->out.info);
24671                 } else {
24672                         r->out.info = NULL;
24673                 }
24674                 if (r->out.info) {
24675                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24676                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24677                         {
24678                                 struct ndr_pull *_ndr_info;
24679                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24680                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24681                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24682                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24683                         }
24684                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24685                 }
24686                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24687                         NDR_PULL_ALLOC(ndr, r->out.needed);
24688                 }
24689                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24690                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24691                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24692                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24693                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24694         }
24695         return NDR_ERR_SUCCESS;
24696 }
24697
24698 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
24699 {
24700         ndr_print_struct(ndr, name, "spoolss_GetForm");
24701         ndr->depth++;
24702         if (flags & NDR_SET_VALUES) {
24703                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24704         }
24705         if (flags & NDR_IN) {
24706                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
24707                 ndr->depth++;
24708                 ndr_print_ptr(ndr, "handle", r->in.handle);
24709                 ndr->depth++;
24710                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24711                 ndr->depth--;
24712                 ndr_print_string(ndr, "form_name", r->in.form_name);
24713                 ndr_print_uint32(ndr, "level", r->in.level);
24714                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24715                 ndr->depth++;
24716                 if (r->in.buffer) {
24717                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24718                 }
24719                 ndr->depth--;
24720                 ndr_print_uint32(ndr, "offered", r->in.offered);
24721                 ndr->depth--;
24722         }
24723         if (flags & NDR_OUT) {
24724                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
24725                 ndr->depth++;
24726                 ndr_print_ptr(ndr, "info", r->out.info);
24727                 ndr->depth++;
24728                 if (r->out.info) {
24729                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24730                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
24731                 }
24732                 ndr->depth--;
24733                 ndr_print_ptr(ndr, "needed", r->out.needed);
24734                 ndr->depth++;
24735                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24736                 ndr->depth--;
24737                 ndr_print_WERROR(ndr, "result", r->out.result);
24738                 ndr->depth--;
24739         }
24740         ndr->depth--;
24741 }
24742
24743 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
24744 {
24745         if (flags & NDR_IN) {
24746                 if (r->in.handle == NULL) {
24747                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24748                 }
24749                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24750                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24751                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24752                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24753                 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));
24754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24755                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
24756                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24757         }
24758         if (flags & NDR_OUT) {
24759                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24760         }
24761         return NDR_ERR_SUCCESS;
24762 }
24763
24764 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
24765 {
24766         TALLOC_CTX *_mem_save_handle_0;
24767         if (flags & NDR_IN) {
24768                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24769                         NDR_PULL_ALLOC(ndr, r->in.handle);
24770                 }
24771                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24772                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24773                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24774                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24775                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24776                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24777                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24778                         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));
24779                 }
24780                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24781                 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));
24782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24783                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
24784                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24785         }
24786         if (flags & NDR_OUT) {
24787                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24788         }
24789         return NDR_ERR_SUCCESS;
24790 }
24791
24792 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
24793 {
24794         ndr_print_struct(ndr, name, "spoolss_SetForm");
24795         ndr->depth++;
24796         if (flags & NDR_SET_VALUES) {
24797                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24798         }
24799         if (flags & NDR_IN) {
24800                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
24801                 ndr->depth++;
24802                 ndr_print_ptr(ndr, "handle", r->in.handle);
24803                 ndr->depth++;
24804                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24805                 ndr->depth--;
24806                 ndr_print_string(ndr, "form_name", r->in.form_name);
24807                 ndr_print_uint32(ndr, "level", r->in.level);
24808                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
24809                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
24810                 ndr->depth--;
24811         }
24812         if (flags & NDR_OUT) {
24813                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
24814                 ndr->depth++;
24815                 ndr_print_WERROR(ndr, "result", r->out.result);
24816                 ndr->depth--;
24817         }
24818         ndr->depth--;
24819 }
24820
24821 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
24822 {
24823         if (flags & NDR_IN) {
24824                 if (r->in.handle == NULL) {
24825                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24826                 }
24827                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24828                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24829                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24830                 if (r->in.buffer) {
24831                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24832                 }
24833                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24834         }
24835         if (flags & NDR_OUT) {
24836                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24837                 if (r->out.info) {
24838                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24839                 }
24840                 if (r->out.needed == NULL) {
24841                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24842                 }
24843                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24844                 if (r->out.count == NULL) {
24845                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24846                 }
24847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24848                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24849         }
24850         return NDR_ERR_SUCCESS;
24851 }
24852
24853 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
24854 {
24855         uint32_t _ptr_buffer;
24856         uint32_t _ptr_info;
24857         TALLOC_CTX *_mem_save_handle_0;
24858         TALLOC_CTX *_mem_save_buffer_0;
24859         TALLOC_CTX *_mem_save_info_0;
24860         TALLOC_CTX *_mem_save_needed_0;
24861         TALLOC_CTX *_mem_save_count_0;
24862         if (flags & NDR_IN) {
24863                 ZERO_STRUCT(r->out);
24864
24865                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24866                         NDR_PULL_ALLOC(ndr, r->in.handle);
24867                 }
24868                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24869                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24870                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24871                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24873                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24874                 if (_ptr_buffer) {
24875                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24876                 } else {
24877                         r->in.buffer = NULL;
24878                 }
24879                 if (r->in.buffer) {
24880                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24881                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24882                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24883                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24884                 }
24885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24886                 NDR_PULL_ALLOC(ndr, r->out.needed);
24887                 ZERO_STRUCTP(r->out.needed);
24888                 NDR_PULL_ALLOC(ndr, r->out.count);
24889                 ZERO_STRUCTP(r->out.count);
24890         }
24891         if (flags & NDR_OUT) {
24892                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24893                 if (_ptr_info) {
24894                         NDR_PULL_ALLOC(ndr, r->out.info);
24895                 } else {
24896                         r->out.info = NULL;
24897                 }
24898                 if (r->out.info) {
24899                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24900                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24901                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24902                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24903                 }
24904                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24905                         NDR_PULL_ALLOC(ndr, r->out.needed);
24906                 }
24907                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24908                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24910                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24911                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24912                         NDR_PULL_ALLOC(ndr, r->out.count);
24913                 }
24914                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24915                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24917                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24918                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24919         }
24920         return NDR_ERR_SUCCESS;
24921 }
24922
24923 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
24924 {
24925         uint32_t cntr_info_0;
24926         if (flags & NDR_IN) {
24927                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24928                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24929         }
24930         if (flags & NDR_OUT) {
24931                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24932                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24933                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24934                 }
24935                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24936                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24937                 }
24938         }
24939         return NDR_ERR_SUCCESS;
24940 }
24941
24942 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
24943 {
24944         uint32_t cntr_info_0;
24945         TALLOC_CTX *_mem_save_info_0;
24946         if (flags & NDR_IN) {
24947                 ZERO_STRUCT(r->out);
24948
24949                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24951         }
24952         if (flags & NDR_OUT) {
24953                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24954                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24955                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24956                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24957                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24958                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24959                 }
24960                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24961                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24962                 }
24963                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24964         }
24965         return NDR_ERR_SUCCESS;
24966 }
24967
24968 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
24969 {
24970         uint32_t cntr_info_2;
24971         ndr_print_struct(ndr, name, "spoolss_EnumForms");
24972         ndr->depth++;
24973         if (flags & NDR_SET_VALUES) {
24974                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24975         }
24976         if (flags & NDR_IN) {
24977                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
24978                 ndr->depth++;
24979                 ndr_print_ptr(ndr, "handle", r->in.handle);
24980                 ndr->depth++;
24981                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24982                 ndr->depth--;
24983                 ndr_print_uint32(ndr, "level", r->in.level);
24984                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24985                 ndr->depth++;
24986                 if (r->in.buffer) {
24987                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24988                 }
24989                 ndr->depth--;
24990                 ndr_print_uint32(ndr, "offered", r->in.offered);
24991                 ndr->depth--;
24992         }
24993         if (flags & NDR_OUT) {
24994                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
24995                 ndr->depth++;
24996                 ndr_print_ptr(ndr, "count", r->out.count);
24997                 ndr->depth++;
24998                 ndr_print_uint32(ndr, "count", *r->out.count);
24999                 ndr->depth--;
25000                 ndr_print_ptr(ndr, "info", r->out.info);
25001                 ndr->depth++;
25002                 ndr_print_ptr(ndr, "info", *r->out.info);
25003                 ndr->depth++;
25004                 if (*r->out.info) {
25005                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
25006                         ndr->depth++;
25007                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
25008                                 char *idx_2=NULL;
25009                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
25010                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
25011                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
25012                                         free(idx_2);
25013                                 }
25014                         }
25015                         ndr->depth--;
25016                 }
25017                 ndr->depth--;
25018                 ndr->depth--;
25019                 ndr_print_ptr(ndr, "needed", r->out.needed);
25020                 ndr->depth++;
25021                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25022                 ndr->depth--;
25023                 ndr_print_WERROR(ndr, "result", r->out.result);
25024                 ndr->depth--;
25025         }
25026         ndr->depth--;
25027 }
25028
25029 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
25030 {
25031         if (flags & NDR_IN) {
25032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
25033                 if (r->in.servername) {
25034                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25035                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25036                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25037                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25038                 }
25039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25040                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25041                 if (r->in.buffer) {
25042                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25043                 }
25044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25045         }
25046         if (flags & NDR_OUT) {
25047                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25048                 if (r->out.info) {
25049                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
25050                 }
25051                 if (r->out.needed == NULL) {
25052                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25053                 }
25054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25055                 if (r->out.count == NULL) {
25056                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25057                 }
25058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
25059                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25060         }
25061         return NDR_ERR_SUCCESS;
25062 }
25063
25064 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
25065 {
25066         uint32_t _ptr_servername;
25067         uint32_t _ptr_buffer;
25068         uint32_t _ptr_info;
25069         TALLOC_CTX *_mem_save_servername_0;
25070         TALLOC_CTX *_mem_save_buffer_0;
25071         TALLOC_CTX *_mem_save_info_0;
25072         TALLOC_CTX *_mem_save_needed_0;
25073         TALLOC_CTX *_mem_save_count_0;
25074         if (flags & NDR_IN) {
25075                 ZERO_STRUCT(r->out);
25076
25077                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
25078                 if (_ptr_servername) {
25079                         NDR_PULL_ALLOC(ndr, r->in.servername);
25080                 } else {
25081                         r->in.servername = NULL;
25082                 }
25083                 if (r->in.servername) {
25084                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25085                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
25086                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
25087                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
25088                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
25089                                 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));
25090                         }
25091                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
25092                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
25093                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
25094                 }
25095                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25096                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25097                 if (_ptr_buffer) {
25098                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25099                 } else {
25100                         r->in.buffer = NULL;
25101                 }
25102                 if (r->in.buffer) {
25103                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25104                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25105                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25106                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25107                 }
25108                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25109                 NDR_PULL_ALLOC(ndr, r->out.needed);
25110                 ZERO_STRUCTP(r->out.needed);
25111                 NDR_PULL_ALLOC(ndr, r->out.count);
25112                 ZERO_STRUCTP(r->out.count);
25113         }
25114         if (flags & NDR_OUT) {
25115                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25116                 if (_ptr_info) {
25117                         NDR_PULL_ALLOC(ndr, r->out.info);
25118                 } else {
25119                         r->out.info = NULL;
25120                 }
25121                 if (r->out.info) {
25122                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25123                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25124                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
25125                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25126                 }
25127                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25128                         NDR_PULL_ALLOC(ndr, r->out.needed);
25129                 }
25130                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25131                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25132                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25133                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25134                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25135                         NDR_PULL_ALLOC(ndr, r->out.count);
25136                 }
25137                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
25138                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
25139                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
25140                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
25141                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25142         }
25143         return NDR_ERR_SUCCESS;
25144 }
25145
25146 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
25147 {
25148         uint32_t cntr_info_0;
25149         if (flags & NDR_IN) {
25150                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25151                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
25152         }
25153         if (flags & NDR_OUT) {
25154                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25155                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25156                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25157                 }
25158                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25159                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25160                 }
25161         }
25162         return NDR_ERR_SUCCESS;
25163 }
25164
25165 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
25166 {
25167         uint32_t cntr_info_0;
25168         TALLOC_CTX *_mem_save_info_0;
25169         if (flags & NDR_IN) {
25170                 ZERO_STRUCT(r->out);
25171
25172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25173                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
25174         }
25175         if (flags & NDR_OUT) {
25176                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
25177                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25178                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25179                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25180                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25181                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25182                 }
25183                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25184                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25185                 }
25186                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25187         }
25188         return NDR_ERR_SUCCESS;
25189 }
25190
25191 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
25192 {
25193         uint32_t cntr_info_2;
25194         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
25195         ndr->depth++;
25196         if (flags & NDR_SET_VALUES) {
25197                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25198         }
25199         if (flags & NDR_IN) {
25200                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
25201                 ndr->depth++;
25202                 ndr_print_ptr(ndr, "servername", r->in.servername);
25203                 ndr->depth++;
25204                 if (r->in.servername) {
25205                         ndr_print_string(ndr, "servername", r->in.servername);
25206                 }
25207                 ndr->depth--;
25208                 ndr_print_uint32(ndr, "level", r->in.level);
25209                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25210                 ndr->depth++;
25211                 if (r->in.buffer) {
25212                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25213                 }
25214                 ndr->depth--;
25215                 ndr_print_uint32(ndr, "offered", r->in.offered);
25216                 ndr->depth--;
25217         }
25218         if (flags & NDR_OUT) {
25219                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
25220                 ndr->depth++;
25221                 ndr_print_ptr(ndr, "count", r->out.count);
25222                 ndr->depth++;
25223                 ndr_print_uint32(ndr, "count", *r->out.count);
25224                 ndr->depth--;
25225                 ndr_print_ptr(ndr, "info", r->out.info);
25226                 ndr->depth++;
25227                 ndr_print_ptr(ndr, "info", *r->out.info);
25228                 ndr->depth++;
25229                 if (*r->out.info) {
25230                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
25231                         ndr->depth++;
25232                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
25233                                 char *idx_2=NULL;
25234                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
25235                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
25236                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
25237                                         free(idx_2);
25238                                 }
25239                         }
25240                         ndr->depth--;
25241                 }
25242                 ndr->depth--;
25243                 ndr->depth--;
25244                 ndr_print_ptr(ndr, "needed", r->out.needed);
25245                 ndr->depth++;
25246                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25247                 ndr->depth--;
25248                 ndr_print_WERROR(ndr, "result", r->out.result);
25249                 ndr->depth--;
25250         }
25251         ndr->depth--;
25252 }
25253
25254 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
25255 {
25256         if (flags & NDR_IN) {
25257                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
25258                 if (r->in.servername) {
25259                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25260                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25261                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25262                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25263                 }
25264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25265                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25266                 if (r->in.buffer) {
25267                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25268                 }
25269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25270         }
25271         if (flags & NDR_OUT) {
25272                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25273                 if (r->out.info) {
25274                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
25275                 }
25276                 if (r->out.needed == NULL) {
25277                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25278                 }
25279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25280                 if (r->out.count == NULL) {
25281                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25282                 }
25283                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
25284                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25285         }
25286         return NDR_ERR_SUCCESS;
25287 }
25288
25289 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
25290 {
25291         uint32_t _ptr_servername;
25292         uint32_t _ptr_buffer;
25293         uint32_t _ptr_info;
25294         TALLOC_CTX *_mem_save_servername_0;
25295         TALLOC_CTX *_mem_save_buffer_0;
25296         TALLOC_CTX *_mem_save_info_0;
25297         TALLOC_CTX *_mem_save_needed_0;
25298         TALLOC_CTX *_mem_save_count_0;
25299         if (flags & NDR_IN) {
25300                 ZERO_STRUCT(r->out);
25301
25302                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
25303                 if (_ptr_servername) {
25304                         NDR_PULL_ALLOC(ndr, r->in.servername);
25305                 } else {
25306                         r->in.servername = NULL;
25307                 }
25308                 if (r->in.servername) {
25309                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25310                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
25311                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
25312                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
25313                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
25314                                 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));
25315                         }
25316                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
25317                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
25318                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
25319                 }
25320                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25321                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25322                 if (_ptr_buffer) {
25323                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25324                 } else {
25325                         r->in.buffer = NULL;
25326                 }
25327                 if (r->in.buffer) {
25328                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25329                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25330                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25331                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25332                 }
25333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25334                 NDR_PULL_ALLOC(ndr, r->out.needed);
25335                 ZERO_STRUCTP(r->out.needed);
25336                 NDR_PULL_ALLOC(ndr, r->out.count);
25337                 ZERO_STRUCTP(r->out.count);
25338         }
25339         if (flags & NDR_OUT) {
25340                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25341                 if (_ptr_info) {
25342                         NDR_PULL_ALLOC(ndr, r->out.info);
25343                 } else {
25344                         r->out.info = NULL;
25345                 }
25346                 if (r->out.info) {
25347                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25348                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25349                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
25350                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25351                 }
25352                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25353                         NDR_PULL_ALLOC(ndr, r->out.needed);
25354                 }
25355                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25356                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25357                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25358                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25359                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25360                         NDR_PULL_ALLOC(ndr, r->out.count);
25361                 }
25362                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
25363                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
25364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
25365                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
25366                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25367         }
25368         return NDR_ERR_SUCCESS;
25369 }
25370
25371 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
25372 {
25373         uint32_t cntr_info_0;
25374         if (flags & NDR_IN) {
25375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25376                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
25377         }
25378         if (flags & NDR_OUT) {
25379                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25380                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25381                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25382                 }
25383                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25384                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25385                 }
25386         }
25387         return NDR_ERR_SUCCESS;
25388 }
25389
25390 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
25391 {
25392         uint32_t cntr_info_0;
25393         TALLOC_CTX *_mem_save_info_0;
25394         if (flags & NDR_IN) {
25395                 ZERO_STRUCT(r->out);
25396
25397                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25398                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
25399         }
25400         if (flags & NDR_OUT) {
25401                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
25402                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25403                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25404                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25405                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25406                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25407                 }
25408                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25409                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25410                 }
25411                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25412         }
25413         return NDR_ERR_SUCCESS;
25414 }
25415
25416 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
25417 {
25418         uint32_t cntr_info_2;
25419         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
25420         ndr->depth++;
25421         if (flags & NDR_SET_VALUES) {
25422                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25423         }
25424         if (flags & NDR_IN) {
25425                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
25426                 ndr->depth++;
25427                 ndr_print_ptr(ndr, "servername", r->in.servername);
25428                 ndr->depth++;
25429                 if (r->in.servername) {
25430                         ndr_print_string(ndr, "servername", r->in.servername);
25431                 }
25432                 ndr->depth--;
25433                 ndr_print_uint32(ndr, "level", r->in.level);
25434                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25435                 ndr->depth++;
25436                 if (r->in.buffer) {
25437                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25438                 }
25439                 ndr->depth--;
25440                 ndr_print_uint32(ndr, "offered", r->in.offered);
25441                 ndr->depth--;
25442         }
25443         if (flags & NDR_OUT) {
25444                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
25445                 ndr->depth++;
25446                 ndr_print_ptr(ndr, "count", r->out.count);
25447                 ndr->depth++;
25448                 ndr_print_uint32(ndr, "count", *r->out.count);
25449                 ndr->depth--;
25450                 ndr_print_ptr(ndr, "info", r->out.info);
25451                 ndr->depth++;
25452                 ndr_print_ptr(ndr, "info", *r->out.info);
25453                 ndr->depth++;
25454                 if (*r->out.info) {
25455                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
25456                         ndr->depth++;
25457                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
25458                                 char *idx_2=NULL;
25459                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
25460                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
25461                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
25462                                         free(idx_2);
25463                                 }
25464                         }
25465                         ndr->depth--;
25466                 }
25467                 ndr->depth--;
25468                 ndr->depth--;
25469                 ndr_print_ptr(ndr, "needed", r->out.needed);
25470                 ndr->depth++;
25471                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25472                 ndr->depth--;
25473                 ndr_print_WERROR(ndr, "result", r->out.result);
25474                 ndr->depth--;
25475         }
25476         ndr->depth--;
25477 }
25478
25479 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
25480 {
25481         if (flags & NDR_IN) {
25482                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
25483                 if (r->in.server_name) {
25484                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
25485                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25486                         NDR_CHECK(ndr_push_uint3264(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                 }
25489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
25490                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
25491                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25492                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
25493                 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));
25494         }
25495         if (flags & NDR_OUT) {
25496                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25497         }
25498         return NDR_ERR_SUCCESS;
25499 }
25500
25501 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
25502 {
25503         uint32_t _ptr_server_name;
25504         TALLOC_CTX *_mem_save_server_name_0;
25505         if (flags & NDR_IN) {
25506                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
25507                 if (_ptr_server_name) {
25508                         NDR_PULL_ALLOC(ndr, r->in.server_name);
25509                 } else {
25510                         r->in.server_name = NULL;
25511                 }
25512                 if (r->in.server_name) {
25513                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
25514                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
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_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
25523                 }
25524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
25525                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
25526                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
25527                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
25528                         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));
25529                 }
25530                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
25531                 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));
25532         }
25533         if (flags & NDR_OUT) {
25534                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25535         }
25536         return NDR_ERR_SUCCESS;
25537 }
25538
25539 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
25540 {
25541         ndr_print_struct(ndr, name, "spoolss_AddPort");
25542         ndr->depth++;
25543         if (flags & NDR_SET_VALUES) {
25544                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25545         }
25546         if (flags & NDR_IN) {
25547                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
25548                 ndr->depth++;
25549                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
25550                 ndr->depth++;
25551                 if (r->in.server_name) {
25552                         ndr_print_string(ndr, "server_name", r->in.server_name);
25553                 }
25554                 ndr->depth--;
25555                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
25556                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
25557                 ndr->depth--;
25558         }
25559         if (flags & NDR_OUT) {
25560                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
25561                 ndr->depth++;
25562                 ndr_print_WERROR(ndr, "result", r->out.result);
25563                 ndr->depth--;
25564         }
25565         ndr->depth--;
25566 }
25567
25568 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
25569 {
25570         if (flags & NDR_IN) {
25571         }
25572         if (flags & NDR_OUT) {
25573                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25574         }
25575         return NDR_ERR_SUCCESS;
25576 }
25577
25578 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
25579 {
25580         if (flags & NDR_IN) {
25581         }
25582         if (flags & NDR_OUT) {
25583                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25584         }
25585         return NDR_ERR_SUCCESS;
25586 }
25587
25588 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
25589 {
25590         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
25591         ndr->depth++;
25592         if (flags & NDR_SET_VALUES) {
25593                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25594         }
25595         if (flags & NDR_IN) {
25596                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
25597                 ndr->depth++;
25598                 ndr->depth--;
25599         }
25600         if (flags & NDR_OUT) {
25601                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
25602                 ndr->depth++;
25603                 ndr_print_WERROR(ndr, "result", r->out.result);
25604                 ndr->depth--;
25605         }
25606         ndr->depth--;
25607 }
25608
25609 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
25610 {
25611         if (flags & NDR_IN) {
25612         }
25613         if (flags & NDR_OUT) {
25614                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25615         }
25616         return NDR_ERR_SUCCESS;
25617 }
25618
25619 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
25620 {
25621         if (flags & NDR_IN) {
25622         }
25623         if (flags & NDR_OUT) {
25624                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25625         }
25626         return NDR_ERR_SUCCESS;
25627 }
25628
25629 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
25630 {
25631         ndr_print_struct(ndr, name, "spoolss_DeletePort");
25632         ndr->depth++;
25633         if (flags & NDR_SET_VALUES) {
25634                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25635         }
25636         if (flags & NDR_IN) {
25637                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
25638                 ndr->depth++;
25639                 ndr->depth--;
25640         }
25641         if (flags & NDR_OUT) {
25642                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
25643                 ndr->depth++;
25644                 ndr_print_WERROR(ndr, "result", r->out.result);
25645                 ndr->depth--;
25646         }
25647         ndr->depth--;
25648 }
25649
25650 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
25651 {
25652         if (flags & NDR_IN) {
25653                 if (r->in.handle == NULL) {
25654                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25655                 }
25656                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25657                 if (r->in.devmode_ctr == NULL) {
25658                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25659                 }
25660                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25661         }
25662         if (flags & NDR_OUT) {
25663                 if (r->out.gdi_handle == NULL) {
25664                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25665                 }
25666                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25667                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25668         }
25669         return NDR_ERR_SUCCESS;
25670 }
25671
25672 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
25673 {
25674         TALLOC_CTX *_mem_save_handle_0;
25675         TALLOC_CTX *_mem_save_gdi_handle_0;
25676         TALLOC_CTX *_mem_save_devmode_ctr_0;
25677         if (flags & NDR_IN) {
25678                 ZERO_STRUCT(r->out);
25679
25680                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25681                         NDR_PULL_ALLOC(ndr, r->in.handle);
25682                 }
25683                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25684                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25685                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25686                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25687                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25688                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25689                 }
25690                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25691                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25692                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25693                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25694                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25695                 ZERO_STRUCTP(r->out.gdi_handle);
25696         }
25697         if (flags & NDR_OUT) {
25698                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25699                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25700                 }
25701                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25702                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25703                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25704                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25705                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25706         }
25707         return NDR_ERR_SUCCESS;
25708 }
25709
25710 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
25711 {
25712         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
25713         ndr->depth++;
25714         if (flags & NDR_SET_VALUES) {
25715                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25716         }
25717         if (flags & NDR_IN) {
25718                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
25719                 ndr->depth++;
25720                 ndr_print_ptr(ndr, "handle", r->in.handle);
25721                 ndr->depth++;
25722                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25723                 ndr->depth--;
25724                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25725                 ndr->depth++;
25726                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25727                 ndr->depth--;
25728                 ndr->depth--;
25729         }
25730         if (flags & NDR_OUT) {
25731                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
25732                 ndr->depth++;
25733                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25734                 ndr->depth++;
25735                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25736                 ndr->depth--;
25737                 ndr_print_WERROR(ndr, "result", r->out.result);
25738                 ndr->depth--;
25739         }
25740         ndr->depth--;
25741 }
25742
25743 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
25744 {
25745         if (flags & NDR_IN) {
25746         }
25747         if (flags & NDR_OUT) {
25748                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25749         }
25750         return NDR_ERR_SUCCESS;
25751 }
25752
25753 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
25754 {
25755         if (flags & NDR_IN) {
25756         }
25757         if (flags & NDR_OUT) {
25758                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25759         }
25760         return NDR_ERR_SUCCESS;
25761 }
25762
25763 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
25764 {
25765         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
25766         ndr->depth++;
25767         if (flags & NDR_SET_VALUES) {
25768                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25769         }
25770         if (flags & NDR_IN) {
25771                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
25772                 ndr->depth++;
25773                 ndr->depth--;
25774         }
25775         if (flags & NDR_OUT) {
25776                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
25777                 ndr->depth++;
25778                 ndr_print_WERROR(ndr, "result", r->out.result);
25779                 ndr->depth--;
25780         }
25781         ndr->depth--;
25782 }
25783
25784 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
25785 {
25786         if (flags & NDR_IN) {
25787                 if (r->in.gdi_handle == NULL) {
25788                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25789                 }
25790                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
25791         }
25792         if (flags & NDR_OUT) {
25793                 if (r->out.gdi_handle == NULL) {
25794                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25795                 }
25796                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25797                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25798         }
25799         return NDR_ERR_SUCCESS;
25800 }
25801
25802 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
25803 {
25804         TALLOC_CTX *_mem_save_gdi_handle_0;
25805         if (flags & NDR_IN) {
25806                 ZERO_STRUCT(r->out);
25807
25808                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25809                         NDR_PULL_ALLOC(ndr, r->in.gdi_handle);
25810                 }
25811                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25812                 NDR_PULL_SET_MEM_CTX(ndr, r->in.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25813                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
25814                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25815                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25816                 *r->out.gdi_handle = *r->in.gdi_handle;
25817         }
25818         if (flags & NDR_OUT) {
25819                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25820                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25821                 }
25822                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25823                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25824                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25825                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25826                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25827         }
25828         return NDR_ERR_SUCCESS;
25829 }
25830
25831 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
25832 {
25833         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
25834         ndr->depth++;
25835         if (flags & NDR_SET_VALUES) {
25836                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25837         }
25838         if (flags & NDR_IN) {
25839                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
25840                 ndr->depth++;
25841                 ndr_print_ptr(ndr, "gdi_handle", r->in.gdi_handle);
25842                 ndr->depth++;
25843                 ndr_print_policy_handle(ndr, "gdi_handle", r->in.gdi_handle);
25844                 ndr->depth--;
25845                 ndr->depth--;
25846         }
25847         if (flags & NDR_OUT) {
25848                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
25849                 ndr->depth++;
25850                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25851                 ndr->depth++;
25852                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25853                 ndr->depth--;
25854                 ndr_print_WERROR(ndr, "result", r->out.result);
25855                 ndr->depth--;
25856         }
25857         ndr->depth--;
25858 }
25859
25860 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
25861 {
25862         if (flags & NDR_IN) {
25863         }
25864         if (flags & NDR_OUT) {
25865                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25866         }
25867         return NDR_ERR_SUCCESS;
25868 }
25869
25870 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
25871 {
25872         if (flags & NDR_IN) {
25873         }
25874         if (flags & NDR_OUT) {
25875                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25876         }
25877         return NDR_ERR_SUCCESS;
25878 }
25879
25880 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
25881 {
25882         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
25883         ndr->depth++;
25884         if (flags & NDR_SET_VALUES) {
25885                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25886         }
25887         if (flags & NDR_IN) {
25888                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
25889                 ndr->depth++;
25890                 ndr->depth--;
25891         }
25892         if (flags & NDR_OUT) {
25893                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
25894                 ndr->depth++;
25895                 ndr_print_WERROR(ndr, "result", r->out.result);
25896                 ndr->depth--;
25897         }
25898         ndr->depth--;
25899 }
25900
25901 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
25902 {
25903         if (flags & NDR_IN) {
25904         }
25905         if (flags & NDR_OUT) {
25906                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25907         }
25908         return NDR_ERR_SUCCESS;
25909 }
25910
25911 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
25912 {
25913         if (flags & NDR_IN) {
25914         }
25915         if (flags & NDR_OUT) {
25916                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25917         }
25918         return NDR_ERR_SUCCESS;
25919 }
25920
25921 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
25922 {
25923         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
25924         ndr->depth++;
25925         if (flags & NDR_SET_VALUES) {
25926                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25927         }
25928         if (flags & NDR_IN) {
25929                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
25930                 ndr->depth++;
25931                 ndr->depth--;
25932         }
25933         if (flags & NDR_OUT) {
25934                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
25935                 ndr->depth++;
25936                 ndr_print_WERROR(ndr, "result", r->out.result);
25937                 ndr->depth--;
25938         }
25939         ndr->depth--;
25940 }
25941
25942 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
25943 {
25944         if (flags & NDR_IN) {
25945         }
25946         if (flags & NDR_OUT) {
25947                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25948         }
25949         return NDR_ERR_SUCCESS;
25950 }
25951
25952 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
25953 {
25954         if (flags & NDR_IN) {
25955         }
25956         if (flags & NDR_OUT) {
25957                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25958         }
25959         return NDR_ERR_SUCCESS;
25960 }
25961
25962 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
25963 {
25964         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
25965         ndr->depth++;
25966         if (flags & NDR_SET_VALUES) {
25967                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25968         }
25969         if (flags & NDR_IN) {
25970                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
25971                 ndr->depth++;
25972                 ndr->depth--;
25973         }
25974         if (flags & NDR_OUT) {
25975                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
25976                 ndr->depth++;
25977                 ndr_print_WERROR(ndr, "result", r->out.result);
25978                 ndr->depth--;
25979         }
25980         ndr->depth--;
25981 }
25982
25983 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
25984 {
25985         if (flags & NDR_IN) {
25986         }
25987         if (flags & NDR_OUT) {
25988                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25989         }
25990         return NDR_ERR_SUCCESS;
25991 }
25992
25993 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
25994 {
25995         if (flags & NDR_IN) {
25996         }
25997         if (flags & NDR_OUT) {
25998                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25999         }
26000         return NDR_ERR_SUCCESS;
26001 }
26002
26003 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
26004 {
26005         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
26006         ndr->depth++;
26007         if (flags & NDR_SET_VALUES) {
26008                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26009         }
26010         if (flags & NDR_IN) {
26011                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
26012                 ndr->depth++;
26013                 ndr->depth--;
26014         }
26015         if (flags & NDR_OUT) {
26016                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
26017                 ndr->depth++;
26018                 ndr_print_WERROR(ndr, "result", r->out.result);
26019                 ndr->depth--;
26020         }
26021         ndr->depth--;
26022 }
26023
26024 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
26025 {
26026         if (flags & NDR_IN) {
26027         }
26028         if (flags & NDR_OUT) {
26029                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26030         }
26031         return NDR_ERR_SUCCESS;
26032 }
26033
26034 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
26035 {
26036         if (flags & NDR_IN) {
26037         }
26038         if (flags & NDR_OUT) {
26039                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26040         }
26041         return NDR_ERR_SUCCESS;
26042 }
26043
26044 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
26045 {
26046         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
26047         ndr->depth++;
26048         if (flags & NDR_SET_VALUES) {
26049                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26050         }
26051         if (flags & NDR_IN) {
26052                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
26053                 ndr->depth++;
26054                 ndr->depth--;
26055         }
26056         if (flags & NDR_OUT) {
26057                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
26058                 ndr->depth++;
26059                 ndr_print_WERROR(ndr, "result", r->out.result);
26060                 ndr->depth--;
26061         }
26062         ndr->depth--;
26063 }
26064
26065 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
26066 {
26067         if (flags & NDR_IN) {
26068         }
26069         if (flags & NDR_OUT) {
26070                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26071         }
26072         return NDR_ERR_SUCCESS;
26073 }
26074
26075 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
26076 {
26077         if (flags & NDR_IN) {
26078         }
26079         if (flags & NDR_OUT) {
26080                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26081         }
26082         return NDR_ERR_SUCCESS;
26083 }
26084
26085 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
26086 {
26087         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
26088         ndr->depth++;
26089         if (flags & NDR_SET_VALUES) {
26090                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26091         }
26092         if (flags & NDR_IN) {
26093                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
26094                 ndr->depth++;
26095                 ndr->depth--;
26096         }
26097         if (flags & NDR_OUT) {
26098                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
26099                 ndr->depth++;
26100                 ndr_print_WERROR(ndr, "result", r->out.result);
26101                 ndr->depth--;
26102         }
26103         ndr->depth--;
26104 }
26105
26106 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
26107 {
26108         if (flags & NDR_IN) {
26109         }
26110         if (flags & NDR_OUT) {
26111                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26112         }
26113         return NDR_ERR_SUCCESS;
26114 }
26115
26116 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
26117 {
26118         if (flags & NDR_IN) {
26119         }
26120         if (flags & NDR_OUT) {
26121                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26122         }
26123         return NDR_ERR_SUCCESS;
26124 }
26125
26126 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
26127 {
26128         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
26129         ndr->depth++;
26130         if (flags & NDR_SET_VALUES) {
26131                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26132         }
26133         if (flags & NDR_IN) {
26134                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
26135                 ndr->depth++;
26136                 ndr->depth--;
26137         }
26138         if (flags & NDR_OUT) {
26139                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
26140                 ndr->depth++;
26141                 ndr_print_WERROR(ndr, "result", r->out.result);
26142                 ndr->depth--;
26143         }
26144         ndr->depth--;
26145 }
26146
26147 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
26148 {
26149         if (flags & NDR_IN) {
26150         }
26151         if (flags & NDR_OUT) {
26152                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26153         }
26154         return NDR_ERR_SUCCESS;
26155 }
26156
26157 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
26158 {
26159         if (flags & NDR_IN) {
26160         }
26161         if (flags & NDR_OUT) {
26162                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26163         }
26164         return NDR_ERR_SUCCESS;
26165 }
26166
26167 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
26168 {
26169         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
26170         ndr->depth++;
26171         if (flags & NDR_SET_VALUES) {
26172                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26173         }
26174         if (flags & NDR_IN) {
26175                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
26176                 ndr->depth++;
26177                 ndr->depth--;
26178         }
26179         if (flags & NDR_OUT) {
26180                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
26181                 ndr->depth++;
26182                 ndr_print_WERROR(ndr, "result", r->out.result);
26183                 ndr->depth--;
26184         }
26185         ndr->depth--;
26186 }
26187
26188 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
26189 {
26190         if (flags & NDR_IN) {
26191                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
26192                 if (r->in.servername) {
26193                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26194                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26195                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26196                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26197                 }
26198                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
26199                 if (r->in.print_processor_name) {
26200                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
26201                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26202                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
26203                         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));
26204                 }
26205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26206                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26207                 if (r->in.buffer) {
26208                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
26209                 }
26210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26211         }
26212         if (flags & NDR_OUT) {
26213                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
26214                 if (r->out.info) {
26215                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
26216                 }
26217                 if (r->out.needed == NULL) {
26218                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26219                 }
26220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26221                 if (r->out.count == NULL) {
26222                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26223                 }
26224                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
26225                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26226         }
26227         return NDR_ERR_SUCCESS;
26228 }
26229
26230 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
26231 {
26232         uint32_t _ptr_servername;
26233         uint32_t _ptr_print_processor_name;
26234         uint32_t _ptr_buffer;
26235         uint32_t _ptr_info;
26236         TALLOC_CTX *_mem_save_servername_0;
26237         TALLOC_CTX *_mem_save_print_processor_name_0;
26238         TALLOC_CTX *_mem_save_buffer_0;
26239         TALLOC_CTX *_mem_save_info_0;
26240         TALLOC_CTX *_mem_save_needed_0;
26241         TALLOC_CTX *_mem_save_count_0;
26242         if (flags & NDR_IN) {
26243                 ZERO_STRUCT(r->out);
26244
26245                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
26246                 if (_ptr_servername) {
26247                         NDR_PULL_ALLOC(ndr, r->in.servername);
26248                 } else {
26249                         r->in.servername = NULL;
26250                 }
26251                 if (r->in.servername) {
26252                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
26253                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
26254                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
26255                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
26256                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
26257                                 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));
26258                         }
26259                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
26260                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
26261                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
26262                 }
26263                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
26264                 if (_ptr_print_processor_name) {
26265                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
26266                 } else {
26267                         r->in.print_processor_name = NULL;
26268                 }
26269                 if (r->in.print_processor_name) {
26270                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
26271                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
26272                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
26273                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
26274                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
26275                                 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));
26276                         }
26277                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
26278                         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));
26279                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
26280                 }
26281                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26282                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26283                 if (_ptr_buffer) {
26284                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26285                 } else {
26286                         r->in.buffer = NULL;
26287                 }
26288                 if (r->in.buffer) {
26289                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26290                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26291                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
26292                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26293                 }
26294                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26295                 NDR_PULL_ALLOC(ndr, r->out.needed);
26296                 ZERO_STRUCTP(r->out.needed);
26297                 NDR_PULL_ALLOC(ndr, r->out.count);
26298                 ZERO_STRUCTP(r->out.count);
26299         }
26300         if (flags & NDR_OUT) {
26301                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
26302                 if (_ptr_info) {
26303                         NDR_PULL_ALLOC(ndr, r->out.info);
26304                 } else {
26305                         r->out.info = NULL;
26306                 }
26307                 if (r->out.info) {
26308                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26309                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26310                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
26311                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26312                 }
26313                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26314                         NDR_PULL_ALLOC(ndr, r->out.needed);
26315                 }
26316                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26317                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26318                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26319                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26320                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26321                         NDR_PULL_ALLOC(ndr, r->out.count);
26322                 }
26323                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
26324                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
26325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
26326                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
26327                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26328         }
26329         return NDR_ERR_SUCCESS;
26330 }
26331
26332 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
26333 {
26334         uint32_t cntr_info_0;
26335         if (flags & NDR_IN) {
26336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
26338         }
26339         if (flags & NDR_OUT) {
26340                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26341                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
26342                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
26343                 }
26344                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26345                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
26346                 }
26347         }
26348         return NDR_ERR_SUCCESS;
26349 }
26350
26351 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
26352 {
26353         uint32_t cntr_info_0;
26354         TALLOC_CTX *_mem_save_info_0;
26355         if (flags & NDR_IN) {
26356                 ZERO_STRUCT(r->out);
26357
26358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26359                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
26360         }
26361         if (flags & NDR_OUT) {
26362                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
26363                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26364                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26365                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26366                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
26367                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
26368                 }
26369                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26370                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
26371                 }
26372                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26373         }
26374         return NDR_ERR_SUCCESS;
26375 }
26376
26377 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
26378 {
26379         uint32_t cntr_info_2;
26380         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
26381         ndr->depth++;
26382         if (flags & NDR_SET_VALUES) {
26383                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26384         }
26385         if (flags & NDR_IN) {
26386                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
26387                 ndr->depth++;
26388                 ndr_print_ptr(ndr, "servername", r->in.servername);
26389                 ndr->depth++;
26390                 if (r->in.servername) {
26391                         ndr_print_string(ndr, "servername", r->in.servername);
26392                 }
26393                 ndr->depth--;
26394                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
26395                 ndr->depth++;
26396                 if (r->in.print_processor_name) {
26397                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
26398                 }
26399                 ndr->depth--;
26400                 ndr_print_uint32(ndr, "level", r->in.level);
26401                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26402                 ndr->depth++;
26403                 if (r->in.buffer) {
26404                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
26405                 }
26406                 ndr->depth--;
26407                 ndr_print_uint32(ndr, "offered", r->in.offered);
26408                 ndr->depth--;
26409         }
26410         if (flags & NDR_OUT) {
26411                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
26412                 ndr->depth++;
26413                 ndr_print_ptr(ndr, "count", r->out.count);
26414                 ndr->depth++;
26415                 ndr_print_uint32(ndr, "count", *r->out.count);
26416                 ndr->depth--;
26417                 ndr_print_ptr(ndr, "info", r->out.info);
26418                 ndr->depth++;
26419                 ndr_print_ptr(ndr, "info", *r->out.info);
26420                 ndr->depth++;
26421                 if (*r->out.info) {
26422                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
26423                         ndr->depth++;
26424                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
26425                                 char *idx_2=NULL;
26426                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
26427                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
26428                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
26429                                         free(idx_2);
26430                                 }
26431                         }
26432                         ndr->depth--;
26433                 }
26434                 ndr->depth--;
26435                 ndr->depth--;
26436                 ndr_print_ptr(ndr, "needed", r->out.needed);
26437                 ndr->depth++;
26438                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26439                 ndr->depth--;
26440                 ndr_print_WERROR(ndr, "result", r->out.result);
26441                 ndr->depth--;
26442         }
26443         ndr->depth--;
26444 }
26445
26446 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
26447 {
26448         if (flags & NDR_IN) {
26449                 if (r->in.handle == NULL) {
26450                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26451                 }
26452                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26453                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
26454                 if (r->in.data_type) {
26455                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
26456                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26457                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
26458                         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));
26459                 }
26460                 if (r->in.devmode_ctr == NULL) {
26461                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26462                 }
26463                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26464         }
26465         if (flags & NDR_OUT) {
26466                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26467         }
26468         return NDR_ERR_SUCCESS;
26469 }
26470
26471 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
26472 {
26473         uint32_t _ptr_data_type;
26474         TALLOC_CTX *_mem_save_handle_0;
26475         TALLOC_CTX *_mem_save_data_type_0;
26476         TALLOC_CTX *_mem_save_devmode_ctr_0;
26477         if (flags & NDR_IN) {
26478                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26479                         NDR_PULL_ALLOC(ndr, r->in.handle);
26480                 }
26481                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26482                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26483                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26484                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26485                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
26486                 if (_ptr_data_type) {
26487                         NDR_PULL_ALLOC(ndr, r->in.data_type);
26488                 } else {
26489                         r->in.data_type = NULL;
26490                 }
26491                 if (r->in.data_type) {
26492                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26493                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
26494                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
26495                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
26496                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
26497                                 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));
26498                         }
26499                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
26500                         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));
26501                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
26502                 }
26503                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26504                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
26505                 }
26506                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26507                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
26508                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26509                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26510         }
26511         if (flags & NDR_OUT) {
26512                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26513         }
26514         return NDR_ERR_SUCCESS;
26515 }
26516
26517 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
26518 {
26519         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
26520         ndr->depth++;
26521         if (flags & NDR_SET_VALUES) {
26522                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26523         }
26524         if (flags & NDR_IN) {
26525                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
26526                 ndr->depth++;
26527                 ndr_print_ptr(ndr, "handle", r->in.handle);
26528                 ndr->depth++;
26529                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26530                 ndr->depth--;
26531                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
26532                 ndr->depth++;
26533                 if (r->in.data_type) {
26534                         ndr_print_string(ndr, "data_type", r->in.data_type);
26535                 }
26536                 ndr->depth--;
26537                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
26538                 ndr->depth++;
26539                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
26540                 ndr->depth--;
26541                 ndr->depth--;
26542         }
26543         if (flags & NDR_OUT) {
26544                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
26545                 ndr->depth++;
26546                 ndr_print_WERROR(ndr, "result", r->out.result);
26547                 ndr->depth--;
26548         }
26549         ndr->depth--;
26550 }
26551
26552 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
26553 {
26554         if (flags & NDR_IN) {
26555                 if (r->in.handle == NULL) {
26556                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26557                 }
26558                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26559                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
26560                 if (r->in.architecture) {
26561                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26562                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26563                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26564                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26565                 }
26566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26567                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26568                 if (r->in.buffer) {
26569                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
26570                 }
26571                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26572                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
26573                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
26574         }
26575         if (flags & NDR_OUT) {
26576                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
26577                 if (r->out.info) {
26578                         {
26579                                 struct ndr_push *_ndr_info;
26580                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
26581                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
26582                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
26583                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
26584                         }
26585                 }
26586                 if (r->out.needed == NULL) {
26587                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26588                 }
26589                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26590                 if (r->out.server_major_version == NULL) {
26591                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26592                 }
26593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
26594                 if (r->out.server_minor_version == NULL) {
26595                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26596                 }
26597                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
26598                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26599         }
26600         return NDR_ERR_SUCCESS;
26601 }
26602
26603 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
26604 {
26605         uint32_t _ptr_architecture;
26606         uint32_t _ptr_buffer;
26607         uint32_t _ptr_info;
26608         TALLOC_CTX *_mem_save_handle_0;
26609         TALLOC_CTX *_mem_save_architecture_0;
26610         TALLOC_CTX *_mem_save_buffer_0;
26611         TALLOC_CTX *_mem_save_info_0;
26612         TALLOC_CTX *_mem_save_needed_0;
26613         TALLOC_CTX *_mem_save_server_major_version_0;
26614         TALLOC_CTX *_mem_save_server_minor_version_0;
26615         if (flags & NDR_IN) {
26616                 ZERO_STRUCT(r->out);
26617
26618                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26619                         NDR_PULL_ALLOC(ndr, r->in.handle);
26620                 }
26621                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26622                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26623                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26624                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26625                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
26626                 if (_ptr_architecture) {
26627                         NDR_PULL_ALLOC(ndr, r->in.architecture);
26628                 } else {
26629                         r->in.architecture = NULL;
26630                 }
26631                 if (r->in.architecture) {
26632                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
26633                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
26634                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
26635                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
26636                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
26637                                 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));
26638                         }
26639                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
26640                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
26641                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
26642                 }
26643                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26644                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26645                 if (_ptr_buffer) {
26646                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26647                 } else {
26648                         r->in.buffer = NULL;
26649                 }
26650                 if (r->in.buffer) {
26651                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26652                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26653                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
26654                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26655                 }
26656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26657                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
26658                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
26659                 NDR_PULL_ALLOC(ndr, r->out.needed);
26660                 ZERO_STRUCTP(r->out.needed);
26661                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
26662                 ZERO_STRUCTP(r->out.server_major_version);
26663                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
26664                 ZERO_STRUCTP(r->out.server_minor_version);
26665         }
26666         if (flags & NDR_OUT) {
26667                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
26668                 if (_ptr_info) {
26669                         NDR_PULL_ALLOC(ndr, r->out.info);
26670                 } else {
26671                         r->out.info = NULL;
26672                 }
26673                 if (r->out.info) {
26674                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26675                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26676                         {
26677                                 struct ndr_pull *_ndr_info;
26678                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
26679                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
26680                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
26681                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
26682                         }
26683                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26684                 }
26685                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26686                         NDR_PULL_ALLOC(ndr, r->out.needed);
26687                 }
26688                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26689                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26690                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26691                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26692                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26693                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
26694                 }
26695                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
26696                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
26697                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
26698                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
26699                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26700                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
26701                 }
26702                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
26703                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
26704                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
26705                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
26706                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26707         }
26708         return NDR_ERR_SUCCESS;
26709 }
26710
26711 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
26712 {
26713         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
26714         ndr->depth++;
26715         if (flags & NDR_SET_VALUES) {
26716                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26717         }
26718         if (flags & NDR_IN) {
26719                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
26720                 ndr->depth++;
26721                 ndr_print_ptr(ndr, "handle", r->in.handle);
26722                 ndr->depth++;
26723                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26724                 ndr->depth--;
26725                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
26726                 ndr->depth++;
26727                 if (r->in.architecture) {
26728                         ndr_print_string(ndr, "architecture", r->in.architecture);
26729                 }
26730                 ndr->depth--;
26731                 ndr_print_uint32(ndr, "level", r->in.level);
26732                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26733                 ndr->depth++;
26734                 if (r->in.buffer) {
26735                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
26736                 }
26737                 ndr->depth--;
26738                 ndr_print_uint32(ndr, "offered", r->in.offered);
26739                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
26740                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
26741                 ndr->depth--;
26742         }
26743         if (flags & NDR_OUT) {
26744                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
26745                 ndr->depth++;
26746                 ndr_print_ptr(ndr, "info", r->out.info);
26747                 ndr->depth++;
26748                 if (r->out.info) {
26749                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
26750                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
26751                 }
26752                 ndr->depth--;
26753                 ndr_print_ptr(ndr, "needed", r->out.needed);
26754                 ndr->depth++;
26755                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26756                 ndr->depth--;
26757                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
26758                 ndr->depth++;
26759                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
26760                 ndr->depth--;
26761                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
26762                 ndr->depth++;
26763                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
26764                 ndr->depth--;
26765                 ndr_print_WERROR(ndr, "result", r->out.result);
26766                 ndr->depth--;
26767         }
26768         ndr->depth--;
26769 }
26770
26771 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
26772 {
26773         if (flags & NDR_IN) {
26774         }
26775         if (flags & NDR_OUT) {
26776                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26777         }
26778         return NDR_ERR_SUCCESS;
26779 }
26780
26781 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
26782 {
26783         if (flags & NDR_IN) {
26784         }
26785         if (flags & NDR_OUT) {
26786                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26787         }
26788         return NDR_ERR_SUCCESS;
26789 }
26790
26791 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
26792 {
26793         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
26794         ndr->depth++;
26795         if (flags & NDR_SET_VALUES) {
26796                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26797         }
26798         if (flags & NDR_IN) {
26799                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
26800                 ndr->depth++;
26801                 ndr->depth--;
26802         }
26803         if (flags & NDR_OUT) {
26804                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
26805                 ndr->depth++;
26806                 ndr_print_WERROR(ndr, "result", r->out.result);
26807                 ndr->depth--;
26808         }
26809         ndr->depth--;
26810 }
26811
26812 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26813 {
26814         if (flags & NDR_IN) {
26815         }
26816         if (flags & NDR_OUT) {
26817                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26818         }
26819         return NDR_ERR_SUCCESS;
26820 }
26821
26822 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
26823 {
26824         if (flags & NDR_IN) {
26825         }
26826         if (flags & NDR_OUT) {
26827                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26828         }
26829         return NDR_ERR_SUCCESS;
26830 }
26831
26832 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26833 {
26834         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
26835         ndr->depth++;
26836         if (flags & NDR_SET_VALUES) {
26837                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26838         }
26839         if (flags & NDR_IN) {
26840                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
26841                 ndr->depth++;
26842                 ndr->depth--;
26843         }
26844         if (flags & NDR_OUT) {
26845                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
26846                 ndr->depth++;
26847                 ndr_print_WERROR(ndr, "result", r->out.result);
26848                 ndr->depth--;
26849         }
26850         ndr->depth--;
26851 }
26852
26853 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
26854 {
26855         if (flags & NDR_IN) {
26856                 if (r->in.handle == NULL) {
26857                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26858                 }
26859                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26860         }
26861         if (flags & NDR_OUT) {
26862                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26863         }
26864         return NDR_ERR_SUCCESS;
26865 }
26866
26867 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
26868 {
26869         TALLOC_CTX *_mem_save_handle_0;
26870         if (flags & NDR_IN) {
26871                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26872                         NDR_PULL_ALLOC(ndr, r->in.handle);
26873                 }
26874                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26875                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26876                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26877                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26878         }
26879         if (flags & NDR_OUT) {
26880                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26881         }
26882         return NDR_ERR_SUCCESS;
26883 }
26884
26885 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
26886 {
26887         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
26888         ndr->depth++;
26889         if (flags & NDR_SET_VALUES) {
26890                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26891         }
26892         if (flags & NDR_IN) {
26893                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
26894                 ndr->depth++;
26895                 ndr_print_ptr(ndr, "handle", r->in.handle);
26896                 ndr->depth++;
26897                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26898                 ndr->depth--;
26899                 ndr->depth--;
26900         }
26901         if (flags & NDR_OUT) {
26902                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
26903                 ndr->depth++;
26904                 ndr_print_WERROR(ndr, "result", r->out.result);
26905                 ndr->depth--;
26906         }
26907         ndr->depth--;
26908 }
26909
26910 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26911 {
26912         if (flags & NDR_IN) {
26913         }
26914         if (flags & NDR_OUT) {
26915                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26916         }
26917         return NDR_ERR_SUCCESS;
26918 }
26919
26920 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26921 {
26922         if (flags & NDR_IN) {
26923         }
26924         if (flags & NDR_OUT) {
26925                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26926         }
26927         return NDR_ERR_SUCCESS;
26928 }
26929
26930 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26931 {
26932         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26933         ndr->depth++;
26934         if (flags & NDR_SET_VALUES) {
26935                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26936         }
26937         if (flags & NDR_IN) {
26938                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26939                 ndr->depth++;
26940                 ndr->depth--;
26941         }
26942         if (flags & NDR_OUT) {
26943                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26944                 ndr->depth++;
26945                 ndr_print_WERROR(ndr, "result", r->out.result);
26946                 ndr->depth--;
26947         }
26948         ndr->depth--;
26949 }
26950
26951 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
26952 {
26953         if (flags & NDR_IN) {
26954                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26955                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26956                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26957                 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));
26958                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
26959                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
26960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
26961                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26962                 if (r->in.buffer) {
26963                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
26964                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
26965                 }
26966         }
26967         if (flags & NDR_OUT) {
26968                 if (r->out.handle == NULL) {
26969                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26970                 }
26971                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26972                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26973         }
26974         return NDR_ERR_SUCCESS;
26975 }
26976
26977 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
26978 {
26979         uint32_t _ptr_buffer;
26980         TALLOC_CTX *_mem_save_buffer_0;
26981         TALLOC_CTX *_mem_save_handle_0;
26982         if (flags & NDR_IN) {
26983                 ZERO_STRUCT(r->out);
26984
26985                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
26986                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
26987                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
26988                         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));
26989                 }
26990                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
26991                 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));
26992                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
26993                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
26994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
26995                 if (r->in.bufsize > 512) {
26996                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
26997                 }
26998                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26999                 if (_ptr_buffer) {
27000                         NDR_PULL_ALLOC(ndr, r->in.buffer);
27001                 } else {
27002                         r->in.buffer = NULL;
27003                 }
27004                 if (r->in.buffer) {
27005                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
27006                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
27007                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
27008                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
27009                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
27010                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
27011                 }
27012                 NDR_PULL_ALLOC(ndr, r->out.handle);
27013                 ZERO_STRUCTP(r->out.handle);
27014                 if (r->in.buffer) {
27015                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
27016                 }
27017         }
27018         if (flags & NDR_OUT) {
27019                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27020                         NDR_PULL_ALLOC(ndr, r->out.handle);
27021                 }
27022                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27023                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27024                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27025                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27026                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27027         }
27028         return NDR_ERR_SUCCESS;
27029 }
27030
27031 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
27032 {
27033         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
27034         ndr->depth++;
27035         if (flags & NDR_SET_VALUES) {
27036                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27037         }
27038         if (flags & NDR_IN) {
27039                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
27040                 ndr->depth++;
27041                 ndr_print_string(ndr, "server_name", r->in.server_name);
27042                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
27043                 ndr_print_winreg_Type(ndr, "type", r->in.type);
27044                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
27045                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
27046                 ndr->depth++;
27047                 if (r->in.buffer) {
27048                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
27049                 }
27050                 ndr->depth--;
27051                 ndr->depth--;
27052         }
27053         if (flags & NDR_OUT) {
27054                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
27055                 ndr->depth++;
27056                 ndr_print_ptr(ndr, "handle", r->out.handle);
27057                 ndr->depth++;
27058                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27059                 ndr->depth--;
27060                 ndr_print_WERROR(ndr, "result", r->out.result);
27061                 ndr->depth--;
27062         }
27063         ndr->depth--;
27064 }
27065
27066 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
27067 {
27068         if (flags & NDR_IN) {
27069                 if (r->in.handle == NULL) {
27070                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27071                 }
27072                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27073                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
27074                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
27075                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
27076                 if (r->in.buffer) {
27077                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
27078                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
27079                 }
27080         }
27081         if (flags & NDR_OUT) {
27082                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27083         }
27084         return NDR_ERR_SUCCESS;
27085 }
27086
27087 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
27088 {
27089         uint32_t _ptr_buffer;
27090         TALLOC_CTX *_mem_save_handle_0;
27091         TALLOC_CTX *_mem_save_buffer_0;
27092         if (flags & NDR_IN) {
27093                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27094                         NDR_PULL_ALLOC(ndr, r->in.handle);
27095                 }
27096                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27097                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27098                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27099                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27100                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
27101                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
27102                 if (r->in.bufsize > 512) {
27103                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
27104                 }
27105                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
27106                 if (_ptr_buffer) {
27107                         NDR_PULL_ALLOC(ndr, r->in.buffer);
27108                 } else {
27109                         r->in.buffer = NULL;
27110                 }
27111                 if (r->in.buffer) {
27112                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
27113                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
27114                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
27115                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
27116                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
27117                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
27118                 }
27119                 if (r->in.buffer) {
27120                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
27121                 }
27122         }
27123         if (flags & NDR_OUT) {
27124                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27125         }
27126         return NDR_ERR_SUCCESS;
27127 }
27128
27129 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
27130 {
27131         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
27132         ndr->depth++;
27133         if (flags & NDR_SET_VALUES) {
27134                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27135         }
27136         if (flags & NDR_IN) {
27137                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
27138                 ndr->depth++;
27139                 ndr_print_ptr(ndr, "handle", r->in.handle);
27140                 ndr->depth++;
27141                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27142                 ndr->depth--;
27143                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
27144                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
27145                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
27146                 ndr->depth++;
27147                 if (r->in.buffer) {
27148                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
27149                 }
27150                 ndr->depth--;
27151                 ndr->depth--;
27152         }
27153         if (flags & NDR_OUT) {
27154                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
27155                 ndr->depth++;
27156                 ndr_print_WERROR(ndr, "result", r->out.result);
27157                 ndr->depth--;
27158         }
27159         ndr->depth--;
27160 }
27161
27162 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
27163 {
27164         if (flags & NDR_IN) {
27165                 if (r->in.handle == NULL) {
27166                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27167                 }
27168                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27169         }
27170         if (flags & NDR_OUT) {
27171                 if (r->out.handle == NULL) {
27172                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27173                 }
27174                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27175                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27176         }
27177         return NDR_ERR_SUCCESS;
27178 }
27179
27180 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
27181 {
27182         TALLOC_CTX *_mem_save_handle_0;
27183         if (flags & NDR_IN) {
27184                 ZERO_STRUCT(r->out);
27185
27186                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27187                         NDR_PULL_ALLOC(ndr, r->in.handle);
27188                 }
27189                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27190                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27191                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27192                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27193                 NDR_PULL_ALLOC(ndr, r->out.handle);
27194                 *r->out.handle = *r->in.handle;
27195         }
27196         if (flags & NDR_OUT) {
27197                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27198                         NDR_PULL_ALLOC(ndr, r->out.handle);
27199                 }
27200                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27201                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27202                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27203                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27204                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27205         }
27206         return NDR_ERR_SUCCESS;
27207 }
27208
27209 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
27210 {
27211         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
27212         ndr->depth++;
27213         if (flags & NDR_SET_VALUES) {
27214                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27215         }
27216         if (flags & NDR_IN) {
27217                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
27218                 ndr->depth++;
27219                 ndr_print_ptr(ndr, "handle", r->in.handle);
27220                 ndr->depth++;
27221                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27222                 ndr->depth--;
27223                 ndr->depth--;
27224         }
27225         if (flags & NDR_OUT) {
27226                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
27227                 ndr->depth++;
27228                 ndr_print_ptr(ndr, "handle", r->out.handle);
27229                 ndr->depth++;
27230                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27231                 ndr->depth--;
27232                 ndr_print_WERROR(ndr, "result", r->out.result);
27233                 ndr->depth--;
27234         }
27235         ndr->depth--;
27236 }
27237
27238 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
27239 {
27240         if (flags & NDR_IN) {
27241         }
27242         if (flags & NDR_OUT) {
27243                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27244         }
27245         return NDR_ERR_SUCCESS;
27246 }
27247
27248 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
27249 {
27250         if (flags & NDR_IN) {
27251         }
27252         if (flags & NDR_OUT) {
27253                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27254         }
27255         return NDR_ERR_SUCCESS;
27256 }
27257
27258 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
27259 {
27260         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
27261         ndr->depth++;
27262         if (flags & NDR_SET_VALUES) {
27263                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27264         }
27265         if (flags & NDR_IN) {
27266                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
27267                 ndr->depth++;
27268                 ndr->depth--;
27269         }
27270         if (flags & NDR_OUT) {
27271                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
27272                 ndr->depth++;
27273                 ndr_print_WERROR(ndr, "result", r->out.result);
27274                 ndr->depth--;
27275         }
27276         ndr->depth--;
27277 }
27278
27279 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
27280 {
27281         if (flags & NDR_IN) {
27282         }
27283         if (flags & NDR_OUT) {
27284                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27285         }
27286         return NDR_ERR_SUCCESS;
27287 }
27288
27289 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
27290 {
27291         if (flags & NDR_IN) {
27292         }
27293         if (flags & NDR_OUT) {
27294                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27295         }
27296         return NDR_ERR_SUCCESS;
27297 }
27298
27299 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
27300 {
27301         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
27302         ndr->depth++;
27303         if (flags & NDR_SET_VALUES) {
27304                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27305         }
27306         if (flags & NDR_IN) {
27307                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
27308                 ndr->depth++;
27309                 ndr->depth--;
27310         }
27311         if (flags & NDR_OUT) {
27312                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
27313                 ndr->depth++;
27314                 ndr_print_WERROR(ndr, "result", r->out.result);
27315                 ndr->depth--;
27316         }
27317         ndr->depth--;
27318 }
27319
27320 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
27321 {
27322         if (flags & NDR_IN) {
27323         }
27324         if (flags & NDR_OUT) {
27325                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27326         }
27327         return NDR_ERR_SUCCESS;
27328 }
27329
27330 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
27331 {
27332         if (flags & NDR_IN) {
27333         }
27334         if (flags & NDR_OUT) {
27335                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27336         }
27337         return NDR_ERR_SUCCESS;
27338 }
27339
27340 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
27341 {
27342         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
27343         ndr->depth++;
27344         if (flags & NDR_SET_VALUES) {
27345                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27346         }
27347         if (flags & NDR_IN) {
27348                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
27349                 ndr->depth++;
27350                 ndr->depth--;
27351         }
27352         if (flags & NDR_OUT) {
27353                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
27354                 ndr->depth++;
27355                 ndr_print_WERROR(ndr, "result", r->out.result);
27356                 ndr->depth--;
27357         }
27358         ndr->depth--;
27359 }
27360
27361 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
27362 {
27363         if (flags & NDR_IN) {
27364         }
27365         if (flags & NDR_OUT) {
27366                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27367         }
27368         return NDR_ERR_SUCCESS;
27369 }
27370
27371 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
27372 {
27373         if (flags & NDR_IN) {
27374         }
27375         if (flags & NDR_OUT) {
27376                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27377         }
27378         return NDR_ERR_SUCCESS;
27379 }
27380
27381 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
27382 {
27383         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
27384         ndr->depth++;
27385         if (flags & NDR_SET_VALUES) {
27386                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27387         }
27388         if (flags & NDR_IN) {
27389                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
27390                 ndr->depth++;
27391                 ndr->depth--;
27392         }
27393         if (flags & NDR_OUT) {
27394                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
27395                 ndr->depth++;
27396                 ndr_print_WERROR(ndr, "result", r->out.result);
27397                 ndr->depth--;
27398         }
27399         ndr->depth--;
27400 }
27401
27402 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
27403 {
27404         if (flags & NDR_IN) {
27405                 if (r->in.handle == NULL) {
27406                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27407                 }
27408                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27409                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
27410                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
27411                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
27412                 if (r->in.local_machine) {
27413                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
27414                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27415                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
27416                         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));
27417                 }
27418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
27419                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
27420                 if (r->in.notify_options) {
27421                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
27422                 }
27423         }
27424         if (flags & NDR_OUT) {
27425                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27426         }
27427         return NDR_ERR_SUCCESS;
27428 }
27429
27430 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
27431 {
27432         uint32_t _ptr_local_machine;
27433         uint32_t _ptr_notify_options;
27434         TALLOC_CTX *_mem_save_handle_0;
27435         TALLOC_CTX *_mem_save_local_machine_0;
27436         TALLOC_CTX *_mem_save_notify_options_0;
27437         if (flags & NDR_IN) {
27438                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27439                         NDR_PULL_ALLOC(ndr, r->in.handle);
27440                 }
27441                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27442                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27443                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27444                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27445                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
27446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
27447                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
27448                 if (_ptr_local_machine) {
27449                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
27450                 } else {
27451                         r->in.local_machine = NULL;
27452                 }
27453                 if (r->in.local_machine) {
27454                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
27455                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
27456                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
27457                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
27458                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
27459                                 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));
27460                         }
27461                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
27462                         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));
27463                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
27464                 }
27465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
27466                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
27467                 if (_ptr_notify_options) {
27468                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
27469                 } else {
27470                         r->in.notify_options = NULL;
27471                 }
27472                 if (r->in.notify_options) {
27473                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
27474                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
27475                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
27476                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
27477                 }
27478         }
27479         if (flags & NDR_OUT) {
27480                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27481         }
27482         return NDR_ERR_SUCCESS;
27483 }
27484
27485 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
27486 {
27487         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
27488         ndr->depth++;
27489         if (flags & NDR_SET_VALUES) {
27490                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27491         }
27492         if (flags & NDR_IN) {
27493                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
27494                 ndr->depth++;
27495                 ndr_print_ptr(ndr, "handle", r->in.handle);
27496                 ndr->depth++;
27497                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27498                 ndr->depth--;
27499                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
27500                 ndr_print_uint32(ndr, "options", r->in.options);
27501                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
27502                 ndr->depth++;
27503                 if (r->in.local_machine) {
27504                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
27505                 }
27506                 ndr->depth--;
27507                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
27508                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
27509                 ndr->depth++;
27510                 if (r->in.notify_options) {
27511                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
27512                 }
27513                 ndr->depth--;
27514                 ndr->depth--;
27515         }
27516         if (flags & NDR_OUT) {
27517                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
27518                 ndr->depth++;
27519                 ndr_print_WERROR(ndr, "result", r->out.result);
27520                 ndr->depth--;
27521         }
27522         ndr->depth--;
27523 }
27524
27525 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
27526 {
27527         if (flags & NDR_IN) {
27528                 if (r->in.handle == NULL) {
27529                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27530                 }
27531                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
27533                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
27534                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
27535                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
27536                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
27537         }
27538         if (flags & NDR_OUT) {
27539                 if (r->out.reply_result == NULL) {
27540                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27541                 }
27542                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
27543                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27544         }
27545         return NDR_ERR_SUCCESS;
27546 }
27547
27548 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
27549 {
27550         TALLOC_CTX *_mem_save_handle_0;
27551         TALLOC_CTX *_mem_save_reply_result_0;
27552         if (flags & NDR_IN) {
27553                 ZERO_STRUCT(r->out);
27554
27555                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27556                         NDR_PULL_ALLOC(ndr, r->in.handle);
27557                 }
27558                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27559                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27560                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27561                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
27563                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
27564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
27565                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
27566                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
27567                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
27568                 ZERO_STRUCTP(r->out.reply_result);
27569         }
27570         if (flags & NDR_OUT) {
27571                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27572                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
27573                 }
27574                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
27575                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
27576                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
27577                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
27578                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27579         }
27580         return NDR_ERR_SUCCESS;
27581 }
27582
27583 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
27584 {
27585         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
27586         ndr->depth++;
27587         if (flags & NDR_SET_VALUES) {
27588                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27589         }
27590         if (flags & NDR_IN) {
27591                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
27592                 ndr->depth++;
27593                 ndr_print_ptr(ndr, "handle", r->in.handle);
27594                 ndr->depth++;
27595                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27596                 ndr->depth--;
27597                 ndr_print_uint32(ndr, "color", r->in.color);
27598                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
27599                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
27600                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
27601                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
27602                 ndr->depth--;
27603         }
27604         if (flags & NDR_OUT) {
27605                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
27606                 ndr->depth++;
27607                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
27608                 ndr->depth++;
27609                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
27610                 ndr->depth--;
27611                 ndr_print_WERROR(ndr, "result", r->out.result);
27612                 ndr->depth--;
27613         }
27614         ndr->depth--;
27615 }
27616
27617 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
27618 {
27619         if (flags & NDR_IN) {
27620                 if (r->in.handle == NULL) {
27621                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27622                 }
27623                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
27625                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
27626                 if (r->in.options) {
27627                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
27628                 }
27629         }
27630         if (flags & NDR_OUT) {
27631                 if (r->out.info == NULL) {
27632                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27633                 }
27634                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
27635                 if (*r->out.info) {
27636                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
27637                 }
27638                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27639         }
27640         return NDR_ERR_SUCCESS;
27641 }
27642
27643 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
27644 {
27645         uint32_t _ptr_options;
27646         uint32_t _ptr_info;
27647         TALLOC_CTX *_mem_save_handle_0;
27648         TALLOC_CTX *_mem_save_options_0;
27649         TALLOC_CTX *_mem_save_info_0;
27650         TALLOC_CTX *_mem_save_info_1;
27651         if (flags & NDR_IN) {
27652                 ZERO_STRUCT(r->out);
27653
27654                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27655                         NDR_PULL_ALLOC(ndr, r->in.handle);
27656                 }
27657                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27658                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27659                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27660                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27661                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
27662                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
27663                 if (_ptr_options) {
27664                         NDR_PULL_ALLOC(ndr, r->in.options);
27665                 } else {
27666                         r->in.options = NULL;
27667                 }
27668                 if (r->in.options) {
27669                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
27670                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
27671                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
27672                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
27673                 }
27674                 NDR_PULL_ALLOC(ndr, r->out.info);
27675                 ZERO_STRUCTP(r->out.info);
27676         }
27677         if (flags & NDR_OUT) {
27678                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27679                         NDR_PULL_ALLOC(ndr, r->out.info);
27680                 }
27681                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
27682                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
27683                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
27684                 if (_ptr_info) {
27685                         NDR_PULL_ALLOC(ndr, *r->out.info);
27686                 } else {
27687                         *r->out.info = NULL;
27688                 }
27689                 if (*r->out.info) {
27690                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
27691                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
27692                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
27693                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
27694                 }
27695                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
27696                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27697         }
27698         return NDR_ERR_SUCCESS;
27699 }
27700
27701 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
27702 {
27703         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
27704         ndr->depth++;
27705         if (flags & NDR_SET_VALUES) {
27706                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27707         }
27708         if (flags & NDR_IN) {
27709                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
27710                 ndr->depth++;
27711                 ndr_print_ptr(ndr, "handle", r->in.handle);
27712                 ndr->depth++;
27713                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27714                 ndr->depth--;
27715                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
27716                 ndr_print_ptr(ndr, "options", r->in.options);
27717                 ndr->depth++;
27718                 if (r->in.options) {
27719                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
27720                 }
27721                 ndr->depth--;
27722                 ndr->depth--;
27723         }
27724         if (flags & NDR_OUT) {
27725                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
27726                 ndr->depth++;
27727                 ndr_print_ptr(ndr, "info", r->out.info);
27728                 ndr->depth++;
27729                 ndr_print_ptr(ndr, "info", *r->out.info);
27730                 ndr->depth++;
27731                 if (*r->out.info) {
27732                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
27733                 }
27734                 ndr->depth--;
27735                 ndr->depth--;
27736                 ndr_print_WERROR(ndr, "result", r->out.result);
27737                 ndr->depth--;
27738         }
27739         ndr->depth--;
27740 }
27741
27742 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
27743 {
27744         if (flags & NDR_IN) {
27745         }
27746         if (flags & NDR_OUT) {
27747                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27748         }
27749         return NDR_ERR_SUCCESS;
27750 }
27751
27752 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
27753 {
27754         if (flags & NDR_IN) {
27755         }
27756         if (flags & NDR_OUT) {
27757                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27758         }
27759         return NDR_ERR_SUCCESS;
27760 }
27761
27762 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
27763 {
27764         ndr_print_struct(ndr, name, "spoolss_44");
27765         ndr->depth++;
27766         if (flags & NDR_SET_VALUES) {
27767                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27768         }
27769         if (flags & NDR_IN) {
27770                 ndr_print_struct(ndr, "in", "spoolss_44");
27771                 ndr->depth++;
27772                 ndr->depth--;
27773         }
27774         if (flags & NDR_OUT) {
27775                 ndr_print_struct(ndr, "out", "spoolss_44");
27776                 ndr->depth++;
27777                 ndr_print_WERROR(ndr, "result", r->out.result);
27778                 ndr->depth--;
27779         }
27780         ndr->depth--;
27781 }
27782
27783 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
27784 {
27785         if (flags & NDR_IN) {
27786                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
27787                 if (r->in.printername) {
27788                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
27789                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27790                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
27791                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27792                 }
27793                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
27794                 if (r->in.datatype) {
27795                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
27796                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27797                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
27798                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27799                 }
27800                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27801                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
27802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
27803                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27804                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27805         }
27806         if (flags & NDR_OUT) {
27807                 if (r->out.handle == NULL) {
27808                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27809                 }
27810                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27811                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27812         }
27813         return NDR_ERR_SUCCESS;
27814 }
27815
27816 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
27817 {
27818         uint32_t _ptr_printername;
27819         uint32_t _ptr_datatype;
27820         TALLOC_CTX *_mem_save_printername_0;
27821         TALLOC_CTX *_mem_save_datatype_0;
27822         TALLOC_CTX *_mem_save_handle_0;
27823         if (flags & NDR_IN) {
27824                 ZERO_STRUCT(r->out);
27825
27826                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
27827                 if (_ptr_printername) {
27828                         NDR_PULL_ALLOC(ndr, r->in.printername);
27829                 } else {
27830                         r->in.printername = NULL;
27831                 }
27832                 if (r->in.printername) {
27833                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
27834                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
27835                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
27836                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
27837                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
27838                                 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));
27839                         }
27840                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
27841                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
27842                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
27843                 }
27844                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
27845                 if (_ptr_datatype) {
27846                         NDR_PULL_ALLOC(ndr, r->in.datatype);
27847                 } else {
27848                         r->in.datatype = NULL;
27849                 }
27850                 if (r->in.datatype) {
27851                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
27852                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
27853                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
27854                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
27855                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
27856                                 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));
27857                         }
27858                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
27859                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
27860                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
27861                 }
27862                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27863                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
27864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
27865                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27866                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27867                 NDR_PULL_ALLOC(ndr, r->out.handle);
27868                 ZERO_STRUCTP(r->out.handle);
27869         }
27870         if (flags & NDR_OUT) {
27871                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27872                         NDR_PULL_ALLOC(ndr, r->out.handle);
27873                 }
27874                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27875                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27876                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27877                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27878                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27879         }
27880         return NDR_ERR_SUCCESS;
27881 }
27882
27883 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
27884 {
27885         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
27886         ndr->depth++;
27887         if (flags & NDR_SET_VALUES) {
27888                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27889         }
27890         if (flags & NDR_IN) {
27891                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
27892                 ndr->depth++;
27893                 ndr_print_ptr(ndr, "printername", r->in.printername);
27894                 ndr->depth++;
27895                 if (r->in.printername) {
27896                         ndr_print_string(ndr, "printername", r->in.printername);
27897                 }
27898                 ndr->depth--;
27899                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
27900                 ndr->depth++;
27901                 if (r->in.datatype) {
27902                         ndr_print_string(ndr, "datatype", r->in.datatype);
27903                 }
27904                 ndr->depth--;
27905                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
27906                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
27907                 ndr_print_uint32(ndr, "level", r->in.level);
27908                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
27909                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
27910                 ndr->depth--;
27911         }
27912         if (flags & NDR_OUT) {
27913                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
27914                 ndr->depth++;
27915                 ndr_print_ptr(ndr, "handle", r->out.handle);
27916                 ndr->depth++;
27917                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27918                 ndr->depth--;
27919                 ndr_print_WERROR(ndr, "result", r->out.result);
27920                 ndr->depth--;
27921         }
27922         ndr->depth--;
27923 }
27924
27925 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
27926 {
27927         if (flags & NDR_IN) {
27928                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
27929                 if (r->in.server) {
27930                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27931                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27932                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27933                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27934                 }
27935                 if (r->in.info_ctr == NULL) {
27936                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27937                 }
27938                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27939                 if (r->in.devmode_ctr == NULL) {
27940                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27941                 }
27942                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27943                 if (r->in.secdesc_ctr == NULL) {
27944                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27945                 }
27946                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
27947                 if (r->in.userlevel_ctr == NULL) {
27948                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27949                 }
27950                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
27951         }
27952         if (flags & NDR_OUT) {
27953                 if (r->out.handle == NULL) {
27954                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27955                 }
27956                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27957                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27958         }
27959         return NDR_ERR_SUCCESS;
27960 }
27961
27962 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
27963 {
27964         uint32_t _ptr_server;
27965         TALLOC_CTX *_mem_save_server_0;
27966         TALLOC_CTX *_mem_save_info_ctr_0;
27967         TALLOC_CTX *_mem_save_devmode_ctr_0;
27968         TALLOC_CTX *_mem_save_secdesc_ctr_0;
27969         TALLOC_CTX *_mem_save_userlevel_ctr_0;
27970         TALLOC_CTX *_mem_save_handle_0;
27971         if (flags & NDR_IN) {
27972                 ZERO_STRUCT(r->out);
27973
27974                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
27975                 if (_ptr_server) {
27976                         NDR_PULL_ALLOC(ndr, r->in.server);
27977                 } else {
27978                         r->in.server = NULL;
27979                 }
27980                 if (r->in.server) {
27981                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
27982                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
27983                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
27984                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
27985                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
27986                                 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));
27987                         }
27988                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
27989                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
27990                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
27991                 }
27992                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27993                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
27994                 }
27995                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27996                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
27997                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27998                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27999                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28000                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
28001                 }
28002                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
28003                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
28004                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
28005                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
28006                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28007                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
28008                 }
28009                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
28010                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
28011                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
28012                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
28013                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28014                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
28015                 }
28016                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
28017                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
28018                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
28019                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
28020                 NDR_PULL_ALLOC(ndr, r->out.handle);
28021                 ZERO_STRUCTP(r->out.handle);
28022         }
28023         if (flags & NDR_OUT) {
28024                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28025                         NDR_PULL_ALLOC(ndr, r->out.handle);
28026                 }
28027                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28028                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
28029                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
28030                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28031                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28032         }
28033         return NDR_ERR_SUCCESS;
28034 }
28035
28036 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
28037 {
28038         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
28039         ndr->depth++;
28040         if (flags & NDR_SET_VALUES) {
28041                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28042         }
28043         if (flags & NDR_IN) {
28044                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
28045                 ndr->depth++;
28046                 ndr_print_ptr(ndr, "server", r->in.server);
28047                 ndr->depth++;
28048                 if (r->in.server) {
28049                         ndr_print_string(ndr, "server", r->in.server);
28050                 }
28051                 ndr->depth--;
28052                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
28053                 ndr->depth++;
28054                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
28055                 ndr->depth--;
28056                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
28057                 ndr->depth++;
28058                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
28059                 ndr->depth--;
28060                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
28061                 ndr->depth++;
28062                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
28063                 ndr->depth--;
28064                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
28065                 ndr->depth++;
28066                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
28067                 ndr->depth--;
28068                 ndr->depth--;
28069         }
28070         if (flags & NDR_OUT) {
28071                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
28072                 ndr->depth++;
28073                 ndr_print_ptr(ndr, "handle", r->out.handle);
28074                 ndr->depth++;
28075                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
28076                 ndr->depth--;
28077                 ndr_print_WERROR(ndr, "result", r->out.result);
28078                 ndr->depth--;
28079         }
28080         ndr->depth--;
28081 }
28082
28083 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
28084 {
28085         if (flags & NDR_IN) {
28086         }
28087         if (flags & NDR_OUT) {
28088                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28089         }
28090         return NDR_ERR_SUCCESS;
28091 }
28092
28093 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
28094 {
28095         if (flags & NDR_IN) {
28096         }
28097         if (flags & NDR_OUT) {
28098                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28099         }
28100         return NDR_ERR_SUCCESS;
28101 }
28102
28103 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
28104 {
28105         ndr_print_struct(ndr, name, "spoolss_47");
28106         ndr->depth++;
28107         if (flags & NDR_SET_VALUES) {
28108                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28109         }
28110         if (flags & NDR_IN) {
28111                 ndr_print_struct(ndr, "in", "spoolss_47");
28112                 ndr->depth++;
28113                 ndr->depth--;
28114         }
28115         if (flags & NDR_OUT) {
28116                 ndr_print_struct(ndr, "out", "spoolss_47");
28117                 ndr->depth++;
28118                 ndr_print_WERROR(ndr, "result", r->out.result);
28119                 ndr->depth--;
28120         }
28121         ndr->depth--;
28122 }
28123
28124 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
28125 {
28126         if (flags & NDR_IN) {
28127                 if (r->in.handle == NULL) {
28128                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28129                 }
28130                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28131                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
28132                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
28133                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
28134         }
28135         if (flags & NDR_OUT) {
28136                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.value_offered / 2));
28137                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
28138                 if (r->out.value_needed == NULL) {
28139                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28140                 }
28141                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
28142                 if (r->out.type == NULL) {
28143                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28144                 }
28145                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
28146                 {
28147                         uint32_t _flags_save_uint8 = ndr->flags;
28148                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
28149                         if (r->out.data == NULL) {
28150                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28151                         }
28152                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_offered));
28153                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
28154                         ndr->flags = _flags_save_uint8;
28155                 }
28156                 if (r->out.data_needed == NULL) {
28157                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28158                 }
28159                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
28160                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28161         }
28162         return NDR_ERR_SUCCESS;
28163 }
28164
28165 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
28166 {
28167         TALLOC_CTX *_mem_save_handle_0;
28168         TALLOC_CTX *_mem_save_value_needed_0;
28169         TALLOC_CTX *_mem_save_type_0;
28170         TALLOC_CTX *_mem_save_data_needed_0;
28171         if (flags & NDR_IN) {
28172                 ZERO_STRUCT(r->out);
28173
28174                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28175                         NDR_PULL_ALLOC(ndr, r->in.handle);
28176                 }
28177                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28178                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28179                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28180                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28181                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
28182                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
28183                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
28184                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
28185                 ZERO_STRUCTP(r->out.value_needed);
28186                 NDR_PULL_ALLOC(ndr, r->out.type);
28187                 ZERO_STRUCTP(r->out.type);
28188                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
28189                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
28190                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
28191                 ZERO_STRUCTP(r->out.data_needed);
28192         }
28193         if (flags & NDR_OUT) {
28194                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
28195                 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));
28196                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28197                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
28198                 }
28199                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28200                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
28201                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
28202                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
28203                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28204                         NDR_PULL_ALLOC(ndr, r->out.type);
28205                 }
28206                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
28207                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
28208                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
28209                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
28210                 {
28211                         uint32_t _flags_save_uint8 = ndr->flags;
28212                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
28213                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
28214                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28215                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
28216                         }
28217                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
28218                         ndr->flags = _flags_save_uint8;
28219                 }
28220                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28221                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
28222                 }
28223                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28224                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
28225                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
28226                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
28227                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28228                 if (r->out.value_name) {
28229                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
28230                 }
28231                 if (r->out.data) {
28232                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
28233                 }
28234         }
28235         return NDR_ERR_SUCCESS;
28236 }
28237
28238 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
28239 {
28240         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
28241         ndr->depth++;
28242         if (flags & NDR_SET_VALUES) {
28243                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28244         }
28245         if (flags & NDR_IN) {
28246                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
28247                 ndr->depth++;
28248                 ndr_print_ptr(ndr, "handle", r->in.handle);
28249                 ndr->depth++;
28250                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28251                 ndr->depth--;
28252                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
28253                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
28254                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
28255                 ndr->depth--;
28256         }
28257         if (flags & NDR_OUT) {
28258                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
28259                 ndr->depth++;
28260                 ndr_print_string(ndr, "value_name", r->out.value_name);
28261                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
28262                 ndr->depth++;
28263                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
28264                 ndr->depth--;
28265                 ndr_print_ptr(ndr, "type", r->out.type);
28266                 ndr->depth++;
28267                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
28268                 ndr->depth--;
28269                 ndr_print_ptr(ndr, "data", r->out.data);
28270                 ndr->depth++;
28271                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
28272                 ndr->depth--;
28273                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
28274                 ndr->depth++;
28275                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
28276                 ndr->depth--;
28277                 ndr_print_WERROR(ndr, "result", r->out.result);
28278                 ndr->depth--;
28279         }
28280         ndr->depth--;
28281 }
28282
28283 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
28284 {
28285         if (flags & NDR_IN) {
28286                 if (r->in.handle == NULL) {
28287                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28288                 }
28289                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28290                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28291                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28292                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28293                 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));
28294         }
28295         if (flags & NDR_OUT) {
28296                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28297         }
28298         return NDR_ERR_SUCCESS;
28299 }
28300
28301 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
28302 {
28303         TALLOC_CTX *_mem_save_handle_0;
28304         if (flags & NDR_IN) {
28305                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28306                         NDR_PULL_ALLOC(ndr, r->in.handle);
28307                 }
28308                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28309                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28310                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28311                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28312                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28313                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28314                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28315                         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));
28316                 }
28317                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28318                 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));
28319         }
28320         if (flags & NDR_OUT) {
28321                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28322         }
28323         return NDR_ERR_SUCCESS;
28324 }
28325
28326 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
28327 {
28328         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
28329         ndr->depth++;
28330         if (flags & NDR_SET_VALUES) {
28331                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28332         }
28333         if (flags & NDR_IN) {
28334                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
28335                 ndr->depth++;
28336                 ndr_print_ptr(ndr, "handle", r->in.handle);
28337                 ndr->depth++;
28338                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28339                 ndr->depth--;
28340                 ndr_print_string(ndr, "value_name", r->in.value_name);
28341                 ndr->depth--;
28342         }
28343         if (flags & NDR_OUT) {
28344                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
28345                 ndr->depth++;
28346                 ndr_print_WERROR(ndr, "result", r->out.result);
28347                 ndr->depth--;
28348         }
28349         ndr->depth--;
28350 }
28351
28352 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
28353 {
28354         if (flags & NDR_IN) {
28355         }
28356         if (flags & NDR_OUT) {
28357                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28358         }
28359         return NDR_ERR_SUCCESS;
28360 }
28361
28362 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
28363 {
28364         if (flags & NDR_IN) {
28365         }
28366         if (flags & NDR_OUT) {
28367                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28368         }
28369         return NDR_ERR_SUCCESS;
28370 }
28371
28372 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
28373 {
28374         ndr_print_struct(ndr, name, "spoolss_4a");
28375         ndr->depth++;
28376         if (flags & NDR_SET_VALUES) {
28377                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28378         }
28379         if (flags & NDR_IN) {
28380                 ndr_print_struct(ndr, "in", "spoolss_4a");
28381                 ndr->depth++;
28382                 ndr->depth--;
28383         }
28384         if (flags & NDR_OUT) {
28385                 ndr_print_struct(ndr, "out", "spoolss_4a");
28386                 ndr->depth++;
28387                 ndr_print_WERROR(ndr, "result", r->out.result);
28388                 ndr->depth--;
28389         }
28390         ndr->depth--;
28391 }
28392
28393 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
28394 {
28395         if (flags & NDR_IN) {
28396         }
28397         if (flags & NDR_OUT) {
28398                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28399         }
28400         return NDR_ERR_SUCCESS;
28401 }
28402
28403 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
28404 {
28405         if (flags & NDR_IN) {
28406         }
28407         if (flags & NDR_OUT) {
28408                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28409         }
28410         return NDR_ERR_SUCCESS;
28411 }
28412
28413 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
28414 {
28415         ndr_print_struct(ndr, name, "spoolss_4b");
28416         ndr->depth++;
28417         if (flags & NDR_SET_VALUES) {
28418                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28419         }
28420         if (flags & NDR_IN) {
28421                 ndr_print_struct(ndr, "in", "spoolss_4b");
28422                 ndr->depth++;
28423                 ndr->depth--;
28424         }
28425         if (flags & NDR_OUT) {
28426                 ndr_print_struct(ndr, "out", "spoolss_4b");
28427                 ndr->depth++;
28428                 ndr_print_WERROR(ndr, "result", r->out.result);
28429                 ndr->depth--;
28430         }
28431         ndr->depth--;
28432 }
28433
28434 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
28435 {
28436         if (flags & NDR_IN) {
28437         }
28438         if (flags & NDR_OUT) {
28439                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28440         }
28441         return NDR_ERR_SUCCESS;
28442 }
28443
28444 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
28445 {
28446         if (flags & NDR_IN) {
28447         }
28448         if (flags & NDR_OUT) {
28449                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28450         }
28451         return NDR_ERR_SUCCESS;
28452 }
28453
28454 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
28455 {
28456         ndr_print_struct(ndr, name, "spoolss_4c");
28457         ndr->depth++;
28458         if (flags & NDR_SET_VALUES) {
28459                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28460         }
28461         if (flags & NDR_IN) {
28462                 ndr_print_struct(ndr, "in", "spoolss_4c");
28463                 ndr->depth++;
28464                 ndr->depth--;
28465         }
28466         if (flags & NDR_OUT) {
28467                 ndr_print_struct(ndr, "out", "spoolss_4c");
28468                 ndr->depth++;
28469                 ndr_print_WERROR(ndr, "result", r->out.result);
28470                 ndr->depth--;
28471         }
28472         ndr->depth--;
28473 }
28474
28475 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterDataEx *r)
28476 {
28477         if (flags & NDR_IN) {
28478                 if (r->in.handle == NULL) {
28479                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28480                 }
28481                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28482                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28483                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28484                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28485                 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));
28486                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28487                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28488                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28489                 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));
28490                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
28491                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
28492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
28493         }
28494         if (flags & NDR_OUT) {
28495                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28496         }
28497         return NDR_ERR_SUCCESS;
28498 }
28499
28500 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterDataEx *r)
28501 {
28502         if (flags & NDR_IN) {
28503                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
28504         }
28505         if (flags & NDR_OUT) {
28506                 if (r->out.data == NULL) {
28507                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28508                 }
28509                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
28510                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
28511         }
28512         return NDR_ERR_SUCCESS;
28513 }
28514
28515 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
28516 {
28517         TALLOC_CTX *_mem_save_handle_0;
28518         if (flags & NDR_IN) {
28519                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28520                         NDR_PULL_ALLOC(ndr, r->in.handle);
28521                 }
28522                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28523                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28524                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28525                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28526                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28527                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28528                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28529                         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));
28530                 }
28531                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28532                 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));
28533                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28534                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28535                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28536                         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));
28537                 }
28538                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28539                 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));
28540                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
28541                 {
28542                         struct ndr_pull *_ndr_data;
28543                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
28544                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
28545                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
28546                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
28547                 }
28548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
28549         }
28550         if (flags & NDR_OUT) {
28551                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28552         }
28553         return NDR_ERR_SUCCESS;
28554 }
28555
28556 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
28557 {
28558         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
28559         ndr->depth++;
28560         if (flags & NDR_SET_VALUES) {
28561                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28562         }
28563         if (flags & NDR_IN) {
28564                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
28565                 ndr->depth++;
28566                 ndr_print_ptr(ndr, "handle", r->in.handle);
28567                 ndr->depth++;
28568                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28569                 ndr->depth--;
28570                 ndr_print_string(ndr, "key_name", r->in.key_name);
28571                 ndr_print_string(ndr, "value_name", r->in.value_name);
28572                 ndr_print_winreg_Type(ndr, "type", r->in.type);
28573                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
28574                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
28575                 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);
28576                 ndr->depth--;
28577         }
28578         if (flags & NDR_OUT) {
28579                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
28580                 ndr->depth++;
28581                 ndr_print_WERROR(ndr, "result", r->out.result);
28582                 ndr->depth--;
28583         }
28584         ndr->depth--;
28585 }
28586
28587 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterDataEx *r)
28588 {
28589         if (flags & NDR_IN) {
28590                 if (r->in.handle == NULL) {
28591                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28592                 }
28593                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28594                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28595                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28596                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28597                 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));
28598                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28599                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28600                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28601                 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));
28602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28603         }
28604         if (flags & NDR_OUT) {
28605                 if (r->out.type == NULL) {
28606                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28607                 }
28608                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
28609                 if (r->out.data == NULL) {
28610                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28611                 }
28612                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
28613                 if (r->out.needed == NULL) {
28614                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28615                 }
28616                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28617                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28618         }
28619         return NDR_ERR_SUCCESS;
28620 }
28621
28622 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterDataEx *r)
28623 {
28624         TALLOC_CTX *_mem_save_handle_0;
28625         TALLOC_CTX *_mem_save_type_0;
28626         TALLOC_CTX *_mem_save_data_0;
28627         TALLOC_CTX *_mem_save_needed_0;
28628         if (flags & NDR_IN) {
28629                 ZERO_STRUCT(r->out);
28630
28631                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28632                         NDR_PULL_ALLOC(ndr, r->in.handle);
28633                 }
28634                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28635                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28636                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28637                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28638                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28639                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28640                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28641                         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));
28642                 }
28643                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28644                 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));
28645                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28646                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28647                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28648                         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));
28649                 }
28650                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28651                 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));
28652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28653                 NDR_PULL_ALLOC(ndr, r->out.type);
28654                 ZERO_STRUCTP(r->out.type);
28655                 NDR_PULL_ALLOC(ndr, r->out.data);
28656                 ZERO_STRUCTP(r->out.data);
28657                 NDR_PULL_ALLOC(ndr, r->out.needed);
28658                 ZERO_STRUCTP(r->out.needed);
28659         }
28660         if (flags & NDR_OUT) {
28661                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28662                         NDR_PULL_ALLOC(ndr, r->out.type);
28663                 }
28664                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
28665                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
28666                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
28667                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
28668                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28669                         NDR_PULL_ALLOC(ndr, r->out.data);
28670                 }
28671                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
28672                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
28673                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
28674                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
28675                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28676                         NDR_PULL_ALLOC(ndr, r->out.needed);
28677                 }
28678                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28679                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28680                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28681                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28682                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28683         }
28684         return NDR_ERR_SUCCESS;
28685 }
28686
28687 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterDataEx *r)
28688 {
28689         if (flags & NDR_IN) {
28690                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
28691         }
28692         if (flags & NDR_OUT) {
28693                 if (r->out.data == NULL) {
28694                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28695                 }
28696                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
28697                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
28698         }
28699         return NDR_ERR_SUCCESS;
28700 }
28701
28702 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterDataEx *r)
28703 {
28704         TALLOC_CTX *_mem_save_data_0;
28705         if (flags & NDR_IN) {
28706                 ZERO_STRUCT(r->out);
28707
28708                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
28709                 NDR_PULL_ALLOC(ndr, r->out.data);
28710                 ZERO_STRUCTP(r->out.data);
28711         }
28712         if (flags & NDR_OUT) {
28713                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28714                         NDR_PULL_ALLOC(ndr, r->out.data);
28715                 }
28716                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
28717                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
28718                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
28719                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
28720                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
28721         }
28722         return NDR_ERR_SUCCESS;
28723 }
28724
28725 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
28726 {
28727         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
28728         ndr->depth++;
28729         if (flags & NDR_SET_VALUES) {
28730                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28731         }
28732         if (flags & NDR_IN) {
28733                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
28734                 ndr->depth++;
28735                 ndr_print_ptr(ndr, "handle", r->in.handle);
28736                 ndr->depth++;
28737                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28738                 ndr->depth--;
28739                 ndr_print_string(ndr, "key_name", r->in.key_name);
28740                 ndr_print_string(ndr, "value_name", r->in.value_name);
28741                 ndr_print_uint32(ndr, "offered", r->in.offered);
28742                 ndr->depth--;
28743         }
28744         if (flags & NDR_OUT) {
28745                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
28746                 ndr->depth++;
28747                 ndr_print_ptr(ndr, "type", r->out.type);
28748                 ndr->depth++;
28749                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
28750                 ndr->depth--;
28751                 ndr_print_ptr(ndr, "data", r->out.data);
28752                 ndr->depth++;
28753                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
28754                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
28755                 ndr->depth--;
28756                 ndr_print_ptr(ndr, "needed", r->out.needed);
28757                 ndr->depth++;
28758                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28759                 ndr->depth--;
28760                 ndr_print_WERROR(ndr, "result", r->out.result);
28761                 ndr->depth--;
28762         }
28763         ndr->depth--;
28764 }
28765
28766 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
28767 {
28768         if (flags & NDR_IN) {
28769                 if (r->in.handle == NULL) {
28770                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28771                 }
28772                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28773                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28774                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28775                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28776                 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));
28777                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28778         }
28779         if (flags & NDR_OUT) {
28780                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
28781                 if (r->out.needed == NULL) {
28782                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28783                 }
28784                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28785                 if (r->out.count == NULL) {
28786                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28787                 }
28788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
28789                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28790         }
28791         return NDR_ERR_SUCCESS;
28792 }
28793
28794 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
28795 {
28796         TALLOC_CTX *_mem_save_handle_0;
28797         TALLOC_CTX *_mem_save_needed_0;
28798         TALLOC_CTX *_mem_save_count_0;
28799         if (flags & NDR_IN) {
28800                 ZERO_STRUCT(r->out);
28801
28802                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28803                         NDR_PULL_ALLOC(ndr, r->in.handle);
28804                 }
28805                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28806                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28807                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28808                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28809                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28810                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28811                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28812                         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));
28813                 }
28814                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28815                 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));
28816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28817                 NDR_PULL_ALLOC(ndr, r->out.needed);
28818                 ZERO_STRUCTP(r->out.needed);
28819                 NDR_PULL_ALLOC(ndr, r->out.count);
28820                 ZERO_STRUCTP(r->out.count);
28821         }
28822         if (flags & NDR_OUT) {
28823                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
28824                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28825                         NDR_PULL_ALLOC(ndr, r->out.needed);
28826                 }
28827                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28828                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28829                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28830                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28831                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28832                         NDR_PULL_ALLOC(ndr, r->out.count);
28833                 }
28834                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
28835                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
28836                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
28837                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
28838                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28839         }
28840         return NDR_ERR_SUCCESS;
28841 }
28842
28843 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
28844 {
28845         uint32_t cntr_info_0;
28846         if (flags & NDR_IN) {
28847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
28848         }
28849         if (flags & NDR_OUT) {
28850                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28851                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28852                 }
28853                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28854                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28855                 }
28856         }
28857         return NDR_ERR_SUCCESS;
28858 }
28859
28860 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
28861 {
28862         uint32_t cntr_info_0;
28863         TALLOC_CTX *_mem_save_info_0;
28864         if (flags & NDR_IN) {
28865                 ZERO_STRUCT(r->out);
28866
28867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
28868         }
28869         if (flags & NDR_OUT) {
28870                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
28871                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
28872                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
28873                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28874                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28875                 }
28876                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28877                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28878                 }
28879                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
28880         }
28881         return NDR_ERR_SUCCESS;
28882 }
28883
28884 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
28885 {
28886         uint32_t cntr_info_2;
28887         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
28888         ndr->depth++;
28889         if (flags & NDR_SET_VALUES) {
28890                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28891         }
28892         if (flags & NDR_IN) {
28893                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
28894                 ndr->depth++;
28895                 ndr_print_ptr(ndr, "handle", r->in.handle);
28896                 ndr->depth++;
28897                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28898                 ndr->depth--;
28899                 ndr_print_string(ndr, "key_name", r->in.key_name);
28900                 ndr_print_uint32(ndr, "offered", r->in.offered);
28901                 ndr->depth--;
28902         }
28903         if (flags & NDR_OUT) {
28904                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
28905                 ndr->depth++;
28906                 ndr_print_ptr(ndr, "count", r->out.count);
28907                 ndr->depth++;
28908                 ndr_print_uint32(ndr, "count", *r->out.count);
28909                 ndr->depth--;
28910                 ndr_print_ptr(ndr, "info", r->out.info);
28911                 ndr->depth++;
28912                 ndr_print_ptr(ndr, "info", *r->out.info);
28913                 ndr->depth++;
28914                 if (*r->out.info) {
28915                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
28916                         ndr->depth++;
28917                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
28918                                 char *idx_2=NULL;
28919                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
28920                                         ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
28921                                         free(idx_2);
28922                                 }
28923                         }
28924                         ndr->depth--;
28925                 }
28926                 ndr->depth--;
28927                 ndr->depth--;
28928                 ndr_print_ptr(ndr, "needed", r->out.needed);
28929                 ndr->depth++;
28930                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28931                 ndr->depth--;
28932                 ndr_print_WERROR(ndr, "result", r->out.result);
28933                 ndr->depth--;
28934         }
28935         ndr->depth--;
28936 }
28937
28938 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
28939 {
28940         if (flags & NDR_IN) {
28941                 if (r->in.handle == NULL) {
28942                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28943                 }
28944                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28945                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28946                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28947                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28948                 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));
28949                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28950         }
28951         if (flags & NDR_OUT) {
28952                 if (r->out._ndr_size == NULL) {
28953                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28954                 }
28955                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._ndr_size));
28956                 if (r->out.key_buffer == NULL) {
28957                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28958                 }
28959                 {
28960                         struct ndr_push *_ndr_key_buffer;
28961                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
28962                         NDR_CHECK(ndr_push_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
28963                         NDR_CHECK(ndr_push_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
28964                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
28965                 }
28966                 if (r->out.needed == NULL) {
28967                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28968                 }
28969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28970                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28971         }
28972         return NDR_ERR_SUCCESS;
28973 }
28974
28975 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
28976 {
28977         TALLOC_CTX *_mem_save_handle_0;
28978         TALLOC_CTX *_mem_save__ndr_size_0;
28979         TALLOC_CTX *_mem_save_key_buffer_0;
28980         TALLOC_CTX *_mem_save_needed_0;
28981         if (flags & NDR_IN) {
28982                 ZERO_STRUCT(r->out);
28983
28984                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28985                         NDR_PULL_ALLOC(ndr, r->in.handle);
28986                 }
28987                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28988                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28989                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28990                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28991                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28992                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28993                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28994                         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));
28995                 }
28996                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28997                 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));
28998                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28999                 NDR_PULL_ALLOC(ndr, r->out._ndr_size);
29000                 ZERO_STRUCTP(r->out._ndr_size);
29001                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
29002                 ZERO_STRUCTP(r->out.key_buffer);
29003                 NDR_PULL_ALLOC(ndr, r->out.needed);
29004                 ZERO_STRUCTP(r->out.needed);
29005         }
29006         if (flags & NDR_OUT) {
29007                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29008                         NDR_PULL_ALLOC(ndr, r->out._ndr_size);
29009                 }
29010                 _mem_save__ndr_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
29011                 NDR_PULL_SET_MEM_CTX(ndr, r->out._ndr_size, LIBNDR_FLAG_REF_ALLOC);
29012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._ndr_size));
29013                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__ndr_size_0, LIBNDR_FLAG_REF_ALLOC);
29014                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29015                         NDR_PULL_ALLOC(ndr, r->out.key_buffer);
29016                 }
29017                 _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
29018                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
29019                 {
29020                         struct ndr_pull *_ndr_key_buffer;
29021                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
29022                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
29023                         NDR_CHECK(ndr_pull_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
29024                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
29025                 }
29026                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
29027                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29028                         NDR_PULL_ALLOC(ndr, r->out.needed);
29029                 }
29030                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
29031                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
29032                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
29033                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
29034                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29035         }
29036         return NDR_ERR_SUCCESS;
29037 }
29038
29039 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
29040 {
29041         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
29042         ndr->depth++;
29043         if (flags & NDR_SET_VALUES) {
29044                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29045         }
29046         if (flags & NDR_IN) {
29047                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
29048                 ndr->depth++;
29049                 ndr_print_ptr(ndr, "handle", r->in.handle);
29050                 ndr->depth++;
29051                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
29052                 ndr->depth--;
29053                 ndr_print_string(ndr, "key_name", r->in.key_name);
29054                 ndr_print_uint32(ndr, "offered", r->in.offered);
29055                 ndr->depth--;
29056         }
29057         if (flags & NDR_OUT) {
29058                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
29059                 ndr->depth++;
29060                 ndr_print_ptr(ndr, "_ndr_size", r->out._ndr_size);
29061                 ndr->depth++;
29062                 ndr_print_uint32(ndr, "_ndr_size", *r->out._ndr_size);
29063                 ndr->depth--;
29064                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
29065                 ndr->depth++;
29066                 ndr_print_set_switch_value(ndr, r->out.key_buffer, *r->out._ndr_size);
29067                 ndr_print_spoolss_KeyNames(ndr, "key_buffer", r->out.key_buffer);
29068                 ndr->depth--;
29069                 ndr_print_ptr(ndr, "needed", r->out.needed);
29070                 ndr->depth++;
29071                 ndr_print_uint32(ndr, "needed", *r->out.needed);
29072                 ndr->depth--;
29073                 ndr_print_WERROR(ndr, "result", r->out.result);
29074                 ndr->depth--;
29075         }
29076         ndr->depth--;
29077 }
29078
29079 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
29080 {
29081         if (flags & NDR_IN) {
29082                 if (r->in.handle == NULL) {
29083                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29084                 }
29085                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29086                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
29087                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29088                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
29089                 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));
29090                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
29091                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29092                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
29093                 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));
29094         }
29095         if (flags & NDR_OUT) {
29096                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29097         }
29098         return NDR_ERR_SUCCESS;
29099 }
29100
29101 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
29102 {
29103         TALLOC_CTX *_mem_save_handle_0;
29104         if (flags & NDR_IN) {
29105                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29106                         NDR_PULL_ALLOC(ndr, r->in.handle);
29107                 }
29108                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
29109                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
29110                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29111                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
29112                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
29113                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
29114                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
29115                         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));
29116                 }
29117                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
29118                 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));
29119                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
29120                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
29121                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
29122                         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));
29123                 }
29124                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
29125                 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));
29126         }
29127         if (flags & NDR_OUT) {
29128                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29129         }
29130         return NDR_ERR_SUCCESS;
29131 }
29132
29133 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
29134 {
29135         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
29136         ndr->depth++;
29137         if (flags & NDR_SET_VALUES) {
29138                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29139         }
29140         if (flags & NDR_IN) {
29141                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
29142                 ndr->depth++;
29143                 ndr_print_ptr(ndr, "handle", r->in.handle);
29144                 ndr->depth++;
29145                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
29146                 ndr->depth--;
29147                 ndr_print_string(ndr, "key_name", r->in.key_name);
29148                 ndr_print_string(ndr, "value_name", r->in.value_name);
29149                 ndr->depth--;
29150         }
29151         if (flags & NDR_OUT) {
29152                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
29153                 ndr->depth++;
29154                 ndr_print_WERROR(ndr, "result", r->out.result);
29155                 ndr->depth--;
29156         }
29157         ndr->depth--;
29158 }
29159
29160 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
29161 {
29162         if (flags & NDR_IN) {
29163                 if (r->in.handle == NULL) {
29164                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29165                 }
29166                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29167                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
29168                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29169                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
29170                 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));
29171         }
29172         if (flags & NDR_OUT) {
29173                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29174         }
29175         return NDR_ERR_SUCCESS;
29176 }
29177
29178 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
29179 {
29180         TALLOC_CTX *_mem_save_handle_0;
29181         if (flags & NDR_IN) {
29182                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29183                         NDR_PULL_ALLOC(ndr, r->in.handle);
29184                 }
29185                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
29186                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
29187                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29188                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
29189                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
29190                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
29191                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
29192                         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));
29193                 }
29194                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
29195                 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));
29196         }
29197         if (flags & NDR_OUT) {
29198                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29199         }
29200         return NDR_ERR_SUCCESS;
29201 }
29202
29203 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
29204 {
29205         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
29206         ndr->depth++;
29207         if (flags & NDR_SET_VALUES) {
29208                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29209         }
29210         if (flags & NDR_IN) {
29211                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
29212                 ndr->depth++;
29213                 ndr_print_ptr(ndr, "handle", r->in.handle);
29214                 ndr->depth++;
29215                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
29216                 ndr->depth--;
29217                 ndr_print_string(ndr, "key_name", r->in.key_name);
29218                 ndr->depth--;
29219         }
29220         if (flags & NDR_OUT) {
29221                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
29222                 ndr->depth++;
29223                 ndr_print_WERROR(ndr, "result", r->out.result);
29224                 ndr->depth--;
29225         }
29226         ndr->depth--;
29227 }
29228
29229 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
29230 {
29231         if (flags & NDR_IN) {
29232         }
29233         if (flags & NDR_OUT) {
29234                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29235         }
29236         return NDR_ERR_SUCCESS;
29237 }
29238
29239 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
29240 {
29241         if (flags & NDR_IN) {
29242         }
29243         if (flags & NDR_OUT) {
29244                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29245         }
29246         return NDR_ERR_SUCCESS;
29247 }
29248
29249 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
29250 {
29251         ndr_print_struct(ndr, name, "spoolss_53");
29252         ndr->depth++;
29253         if (flags & NDR_SET_VALUES) {
29254                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29255         }
29256         if (flags & NDR_IN) {
29257                 ndr_print_struct(ndr, "in", "spoolss_53");
29258                 ndr->depth++;
29259                 ndr->depth--;
29260         }
29261         if (flags & NDR_OUT) {
29262                 ndr_print_struct(ndr, "out", "spoolss_53");
29263                 ndr->depth++;
29264                 ndr_print_WERROR(ndr, "result", r->out.result);
29265                 ndr->depth--;
29266         }
29267         ndr->depth--;
29268 }
29269
29270 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
29271 {
29272         if (flags & NDR_IN) {
29273                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
29274                 if (r->in.server) {
29275                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
29276                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29277                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
29278                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29279                 }
29280                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29281                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29282                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29283                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29284                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
29285                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29286                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
29287                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29288                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
29289                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
29290         }
29291         if (flags & NDR_OUT) {
29292                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29293         }
29294         return NDR_ERR_SUCCESS;
29295 }
29296
29297 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
29298 {
29299         uint32_t _ptr_server;
29300         TALLOC_CTX *_mem_save_server_0;
29301         if (flags & NDR_IN) {
29302                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
29303                 if (_ptr_server) {
29304                         NDR_PULL_ALLOC(ndr, r->in.server);
29305                 } else {
29306                         r->in.server = NULL;
29307                 }
29308                 if (r->in.server) {
29309                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
29310                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
29311                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
29312                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
29313                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
29314                                 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));
29315                         }
29316                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
29317                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
29318                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
29319                 }
29320                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
29321                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
29322                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
29323                         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));
29324                 }
29325                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
29326                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
29327                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
29328                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
29329                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
29330                         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));
29331                 }
29332                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
29333                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
29334                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
29335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
29336         }
29337         if (flags & NDR_OUT) {
29338                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29339         }
29340         return NDR_ERR_SUCCESS;
29341 }
29342
29343 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
29344 {
29345         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
29346         ndr->depth++;
29347         if (flags & NDR_SET_VALUES) {
29348                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29349         }
29350         if (flags & NDR_IN) {
29351                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
29352                 ndr->depth++;
29353                 ndr_print_ptr(ndr, "server", r->in.server);
29354                 ndr->depth++;
29355                 if (r->in.server) {
29356                         ndr_print_string(ndr, "server", r->in.server);
29357                 }
29358                 ndr->depth--;
29359                 ndr_print_string(ndr, "architecture", r->in.architecture);
29360                 ndr_print_string(ndr, "driver", r->in.driver);
29361                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
29362                 ndr_print_uint32(ndr, "version", r->in.version);
29363                 ndr->depth--;
29364         }
29365         if (flags & NDR_OUT) {
29366                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
29367                 ndr->depth++;
29368                 ndr_print_WERROR(ndr, "result", r->out.result);
29369                 ndr->depth--;
29370         }
29371         ndr->depth--;
29372 }
29373
29374 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
29375 {
29376         if (flags & NDR_IN) {
29377         }
29378         if (flags & NDR_OUT) {
29379                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29380         }
29381         return NDR_ERR_SUCCESS;
29382 }
29383
29384 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
29385 {
29386         if (flags & NDR_IN) {
29387         }
29388         if (flags & NDR_OUT) {
29389                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29390         }
29391         return NDR_ERR_SUCCESS;
29392 }
29393
29394 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
29395 {
29396         ndr_print_struct(ndr, name, "spoolss_55");
29397         ndr->depth++;
29398         if (flags & NDR_SET_VALUES) {
29399                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29400         }
29401         if (flags & NDR_IN) {
29402                 ndr_print_struct(ndr, "in", "spoolss_55");
29403                 ndr->depth++;
29404                 ndr->depth--;
29405         }
29406         if (flags & NDR_OUT) {
29407                 ndr_print_struct(ndr, "out", "spoolss_55");
29408                 ndr->depth++;
29409                 ndr_print_WERROR(ndr, "result", r->out.result);
29410                 ndr->depth--;
29411         }
29412         ndr->depth--;
29413 }
29414
29415 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
29416 {
29417         if (flags & NDR_IN) {
29418         }
29419         if (flags & NDR_OUT) {
29420                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29421         }
29422         return NDR_ERR_SUCCESS;
29423 }
29424
29425 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
29426 {
29427         if (flags & NDR_IN) {
29428         }
29429         if (flags & NDR_OUT) {
29430                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29431         }
29432         return NDR_ERR_SUCCESS;
29433 }
29434
29435 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
29436 {
29437         ndr_print_struct(ndr, name, "spoolss_56");
29438         ndr->depth++;
29439         if (flags & NDR_SET_VALUES) {
29440                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29441         }
29442         if (flags & NDR_IN) {
29443                 ndr_print_struct(ndr, "in", "spoolss_56");
29444                 ndr->depth++;
29445                 ndr->depth--;
29446         }
29447         if (flags & NDR_OUT) {
29448                 ndr_print_struct(ndr, "out", "spoolss_56");
29449                 ndr->depth++;
29450                 ndr_print_WERROR(ndr, "result", r->out.result);
29451                 ndr->depth--;
29452         }
29453         ndr->depth--;
29454 }
29455
29456 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
29457 {
29458         if (flags & NDR_IN) {
29459         }
29460         if (flags & NDR_OUT) {
29461                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29462         }
29463         return NDR_ERR_SUCCESS;
29464 }
29465
29466 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
29467 {
29468         if (flags & NDR_IN) {
29469         }
29470         if (flags & NDR_OUT) {
29471                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29472         }
29473         return NDR_ERR_SUCCESS;
29474 }
29475
29476 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
29477 {
29478         ndr_print_struct(ndr, name, "spoolss_57");
29479         ndr->depth++;
29480         if (flags & NDR_SET_VALUES) {
29481                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29482         }
29483         if (flags & NDR_IN) {
29484                 ndr_print_struct(ndr, "in", "spoolss_57");
29485                 ndr->depth++;
29486                 ndr->depth--;
29487         }
29488         if (flags & NDR_OUT) {
29489                 ndr_print_struct(ndr, "out", "spoolss_57");
29490                 ndr->depth++;
29491                 ndr_print_WERROR(ndr, "result", r->out.result);
29492                 ndr->depth--;
29493         }
29494         ndr->depth--;
29495 }
29496
29497 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
29498 {
29499         if (flags & NDR_IN) {
29500                 if (r->in.handle == NULL) {
29501                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29502                 }
29503                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29504                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
29505                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29506                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
29507                 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));
29508                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
29509                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
29510                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
29511                 if (r->in.status_code == NULL) {
29512                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29513                 }
29514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
29515         }
29516         if (flags & NDR_OUT) {
29517                 if (r->out.out_data == NULL) {
29518                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29519                 }
29520                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.out_data_size));
29521                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
29522                 if (r->out.needed == NULL) {
29523                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29524                 }
29525                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
29526                 if (r->out.status_code == NULL) {
29527                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29528                 }
29529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
29530                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29531         }
29532         return NDR_ERR_SUCCESS;
29533 }
29534
29535 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
29536 {
29537         TALLOC_CTX *_mem_save_handle_0;
29538         TALLOC_CTX *_mem_save_needed_0;
29539         TALLOC_CTX *_mem_save_status_code_0;
29540         if (flags & NDR_IN) {
29541                 ZERO_STRUCT(r->out);
29542
29543                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29544                         NDR_PULL_ALLOC(ndr, r->in.handle);
29545                 }
29546                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
29547                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
29548                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29549                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
29550                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
29551                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
29552                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
29553                         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));
29554                 }
29555                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
29556                 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));
29557                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
29558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
29559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
29560                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29561                         NDR_PULL_ALLOC(ndr, r->in.status_code);
29562                 }
29563                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
29564                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
29565                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
29566                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
29567                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
29568                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
29569                 NDR_PULL_ALLOC(ndr, r->out.needed);
29570                 ZERO_STRUCTP(r->out.needed);
29571                 NDR_PULL_ALLOC(ndr, r->out.status_code);
29572                 *r->out.status_code = *r->in.status_code;
29573         }
29574         if (flags & NDR_OUT) {
29575                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
29576                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29577                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
29578                 }
29579                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
29580                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29581                         NDR_PULL_ALLOC(ndr, r->out.needed);
29582                 }
29583                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
29584                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
29585                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
29586                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
29587                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29588                         NDR_PULL_ALLOC(ndr, r->out.status_code);
29589                 }
29590                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
29591                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
29592                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
29593                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
29594                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29595                 if (r->out.out_data) {
29596                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
29597                 }
29598         }
29599         return NDR_ERR_SUCCESS;
29600 }
29601
29602 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
29603 {
29604         ndr_print_struct(ndr, name, "spoolss_XcvData");
29605         ndr->depth++;
29606         if (flags & NDR_SET_VALUES) {
29607                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29608         }
29609         if (flags & NDR_IN) {
29610                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
29611                 ndr->depth++;
29612                 ndr_print_ptr(ndr, "handle", r->in.handle);
29613                 ndr->depth++;
29614                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
29615                 ndr->depth--;
29616                 ndr_print_string(ndr, "function_name", r->in.function_name);
29617                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
29618                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
29619                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
29620                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
29621                 ndr->depth++;
29622                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
29623                 ndr->depth--;
29624                 ndr->depth--;
29625         }
29626         if (flags & NDR_OUT) {
29627                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
29628                 ndr->depth++;
29629                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
29630                 ndr->depth++;
29631                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
29632                 ndr->depth--;
29633                 ndr_print_ptr(ndr, "needed", r->out.needed);
29634                 ndr->depth++;
29635                 ndr_print_uint32(ndr, "needed", *r->out.needed);
29636                 ndr->depth--;
29637                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
29638                 ndr->depth++;
29639                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
29640                 ndr->depth--;
29641                 ndr_print_WERROR(ndr, "result", r->out.result);
29642                 ndr->depth--;
29643         }
29644         ndr->depth--;
29645 }
29646
29647 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
29648 {
29649         if (flags & NDR_IN) {
29650                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29651                 if (r->in.servername) {
29652                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29653                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29654                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29655                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29656                 }
29657                 if (r->in.info_ctr == NULL) {
29658                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29659                 }
29660                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
29661                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
29662         }
29663         if (flags & NDR_OUT) {
29664                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29665         }
29666         return NDR_ERR_SUCCESS;
29667 }
29668
29669 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
29670 {
29671         uint32_t _ptr_servername;
29672         TALLOC_CTX *_mem_save_servername_0;
29673         TALLOC_CTX *_mem_save_info_ctr_0;
29674         if (flags & NDR_IN) {
29675                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29676                 if (_ptr_servername) {
29677                         NDR_PULL_ALLOC(ndr, r->in.servername);
29678                 } else {
29679                         r->in.servername = NULL;
29680                 }
29681                 if (r->in.servername) {
29682                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29683                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29684                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29685                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29686                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29687                                 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));
29688                         }
29689                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29690                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29691                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29692                 }
29693                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29694                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
29695                 }
29696                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
29697                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
29698                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
29699                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
29700                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
29701         }
29702         if (flags & NDR_OUT) {
29703                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29704         }
29705         return NDR_ERR_SUCCESS;
29706 }
29707
29708 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
29709 {
29710         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
29711         ndr->depth++;
29712         if (flags & NDR_SET_VALUES) {
29713                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29714         }
29715         if (flags & NDR_IN) {
29716                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
29717                 ndr->depth++;
29718                 ndr_print_ptr(ndr, "servername", r->in.servername);
29719                 ndr->depth++;
29720                 if (r->in.servername) {
29721                         ndr_print_string(ndr, "servername", r->in.servername);
29722                 }
29723                 ndr->depth--;
29724                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
29725                 ndr->depth++;
29726                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
29727                 ndr->depth--;
29728                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
29729                 ndr->depth--;
29730         }
29731         if (flags & NDR_OUT) {
29732                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
29733                 ndr->depth++;
29734                 ndr_print_WERROR(ndr, "result", r->out.result);
29735                 ndr->depth--;
29736         }
29737         ndr->depth--;
29738 }
29739
29740 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
29741 {
29742         if (flags & NDR_IN) {
29743         }
29744         if (flags & NDR_OUT) {
29745                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29746         }
29747         return NDR_ERR_SUCCESS;
29748 }
29749
29750 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
29751 {
29752         if (flags & NDR_IN) {
29753         }
29754         if (flags & NDR_OUT) {
29755                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29756         }
29757         return NDR_ERR_SUCCESS;
29758 }
29759
29760 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
29761 {
29762         ndr_print_struct(ndr, name, "spoolss_5a");
29763         ndr->depth++;
29764         if (flags & NDR_SET_VALUES) {
29765                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29766         }
29767         if (flags & NDR_IN) {
29768                 ndr_print_struct(ndr, "in", "spoolss_5a");
29769                 ndr->depth++;
29770                 ndr->depth--;
29771         }
29772         if (flags & NDR_OUT) {
29773                 ndr_print_struct(ndr, "out", "spoolss_5a");
29774                 ndr->depth++;
29775                 ndr_print_WERROR(ndr, "result", r->out.result);
29776                 ndr->depth--;
29777         }
29778         ndr->depth--;
29779 }
29780
29781 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
29782 {
29783         if (flags & NDR_IN) {
29784         }
29785         if (flags & NDR_OUT) {
29786                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29787         }
29788         return NDR_ERR_SUCCESS;
29789 }
29790
29791 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
29792 {
29793         if (flags & NDR_IN) {
29794         }
29795         if (flags & NDR_OUT) {
29796                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29797         }
29798         return NDR_ERR_SUCCESS;
29799 }
29800
29801 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
29802 {
29803         ndr_print_struct(ndr, name, "spoolss_5b");
29804         ndr->depth++;
29805         if (flags & NDR_SET_VALUES) {
29806                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29807         }
29808         if (flags & NDR_IN) {
29809                 ndr_print_struct(ndr, "in", "spoolss_5b");
29810                 ndr->depth++;
29811                 ndr->depth--;
29812         }
29813         if (flags & NDR_OUT) {
29814                 ndr_print_struct(ndr, "out", "spoolss_5b");
29815                 ndr->depth++;
29816                 ndr_print_WERROR(ndr, "result", r->out.result);
29817                 ndr->depth--;
29818         }
29819         ndr->depth--;
29820 }
29821
29822 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
29823 {
29824         if (flags & NDR_IN) {
29825         }
29826         if (flags & NDR_OUT) {
29827                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29828         }
29829         return NDR_ERR_SUCCESS;
29830 }
29831
29832 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
29833 {
29834         if (flags & NDR_IN) {
29835         }
29836         if (flags & NDR_OUT) {
29837                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29838         }
29839         return NDR_ERR_SUCCESS;
29840 }
29841
29842 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
29843 {
29844         ndr_print_struct(ndr, name, "spoolss_5c");
29845         ndr->depth++;
29846         if (flags & NDR_SET_VALUES) {
29847                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29848         }
29849         if (flags & NDR_IN) {
29850                 ndr_print_struct(ndr, "in", "spoolss_5c");
29851                 ndr->depth++;
29852                 ndr->depth--;
29853         }
29854         if (flags & NDR_OUT) {
29855                 ndr_print_struct(ndr, "out", "spoolss_5c");
29856                 ndr->depth++;
29857                 ndr_print_WERROR(ndr, "result", r->out.result);
29858                 ndr->depth--;
29859         }
29860         ndr->depth--;
29861 }
29862
29863 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
29864 {
29865         if (flags & NDR_IN) {
29866         }
29867         if (flags & NDR_OUT) {
29868                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29869         }
29870         return NDR_ERR_SUCCESS;
29871 }
29872
29873 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
29874 {
29875         if (flags & NDR_IN) {
29876         }
29877         if (flags & NDR_OUT) {
29878                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29879         }
29880         return NDR_ERR_SUCCESS;
29881 }
29882
29883 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
29884 {
29885         ndr_print_struct(ndr, name, "spoolss_5d");
29886         ndr->depth++;
29887         if (flags & NDR_SET_VALUES) {
29888                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29889         }
29890         if (flags & NDR_IN) {
29891                 ndr_print_struct(ndr, "in", "spoolss_5d");
29892                 ndr->depth++;
29893                 ndr->depth--;
29894         }
29895         if (flags & NDR_OUT) {
29896                 ndr_print_struct(ndr, "out", "spoolss_5d");
29897                 ndr->depth++;
29898                 ndr_print_WERROR(ndr, "result", r->out.result);
29899                 ndr->depth--;
29900         }
29901         ndr->depth--;
29902 }
29903
29904 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
29905 {
29906         if (flags & NDR_IN) {
29907         }
29908         if (flags & NDR_OUT) {
29909                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29910         }
29911         return NDR_ERR_SUCCESS;
29912 }
29913
29914 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
29915 {
29916         if (flags & NDR_IN) {
29917         }
29918         if (flags & NDR_OUT) {
29919                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29920         }
29921         return NDR_ERR_SUCCESS;
29922 }
29923
29924 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
29925 {
29926         ndr_print_struct(ndr, name, "spoolss_5e");
29927         ndr->depth++;
29928         if (flags & NDR_SET_VALUES) {
29929                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29930         }
29931         if (flags & NDR_IN) {
29932                 ndr_print_struct(ndr, "in", "spoolss_5e");
29933                 ndr->depth++;
29934                 ndr->depth--;
29935         }
29936         if (flags & NDR_OUT) {
29937                 ndr_print_struct(ndr, "out", "spoolss_5e");
29938                 ndr->depth++;
29939                 ndr_print_WERROR(ndr, "result", r->out.result);
29940                 ndr->depth--;
29941         }
29942         ndr->depth--;
29943 }
29944
29945 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
29946 {
29947         if (flags & NDR_IN) {
29948         }
29949         if (flags & NDR_OUT) {
29950                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29951         }
29952         return NDR_ERR_SUCCESS;
29953 }
29954
29955 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
29956 {
29957         if (flags & NDR_IN) {
29958         }
29959         if (flags & NDR_OUT) {
29960                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29961         }
29962         return NDR_ERR_SUCCESS;
29963 }
29964
29965 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
29966 {
29967         ndr_print_struct(ndr, name, "spoolss_5f");
29968         ndr->depth++;
29969         if (flags & NDR_SET_VALUES) {
29970                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29971         }
29972         if (flags & NDR_IN) {
29973                 ndr_print_struct(ndr, "in", "spoolss_5f");
29974                 ndr->depth++;
29975                 ndr->depth--;
29976         }
29977         if (flags & NDR_OUT) {
29978                 ndr_print_struct(ndr, "out", "spoolss_5f");
29979                 ndr->depth++;
29980                 ndr_print_WERROR(ndr, "result", r->out.result);
29981                 ndr->depth--;
29982         }
29983         ndr->depth--;
29984 }
29985
29986 static enum ndr_err_code ndr_push_spoolss_60(struct ndr_push *ndr, int flags, const struct spoolss_60 *r)
29987 {
29988         if (flags & NDR_IN) {
29989         }
29990         if (flags & NDR_OUT) {
29991                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29992         }
29993         return NDR_ERR_SUCCESS;
29994 }
29995
29996 static enum ndr_err_code ndr_pull_spoolss_60(struct ndr_pull *ndr, int flags, struct spoolss_60 *r)
29997 {
29998         if (flags & NDR_IN) {
29999         }
30000         if (flags & NDR_OUT) {
30001                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30002         }
30003         return NDR_ERR_SUCCESS;
30004 }
30005
30006 _PUBLIC_ void ndr_print_spoolss_60(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_60 *r)
30007 {
30008         ndr_print_struct(ndr, name, "spoolss_60");
30009         ndr->depth++;
30010         if (flags & NDR_SET_VALUES) {
30011                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30012         }
30013         if (flags & NDR_IN) {
30014                 ndr_print_struct(ndr, "in", "spoolss_60");
30015                 ndr->depth++;
30016                 ndr->depth--;
30017         }
30018         if (flags & NDR_OUT) {
30019                 ndr_print_struct(ndr, "out", "spoolss_60");
30020                 ndr->depth++;
30021                 ndr_print_WERROR(ndr, "result", r->out.result);
30022                 ndr->depth--;
30023         }
30024         ndr->depth--;
30025 }
30026
30027 static enum ndr_err_code ndr_push_spoolss_61(struct ndr_push *ndr, int flags, const struct spoolss_61 *r)
30028 {
30029         if (flags & NDR_IN) {
30030         }
30031         if (flags & NDR_OUT) {
30032                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30033         }
30034         return NDR_ERR_SUCCESS;
30035 }
30036
30037 static enum ndr_err_code ndr_pull_spoolss_61(struct ndr_pull *ndr, int flags, struct spoolss_61 *r)
30038 {
30039         if (flags & NDR_IN) {
30040         }
30041         if (flags & NDR_OUT) {
30042                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30043         }
30044         return NDR_ERR_SUCCESS;
30045 }
30046
30047 _PUBLIC_ void ndr_print_spoolss_61(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_61 *r)
30048 {
30049         ndr_print_struct(ndr, name, "spoolss_61");
30050         ndr->depth++;
30051         if (flags & NDR_SET_VALUES) {
30052                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30053         }
30054         if (flags & NDR_IN) {
30055                 ndr_print_struct(ndr, "in", "spoolss_61");
30056                 ndr->depth++;
30057                 ndr->depth--;
30058         }
30059         if (flags & NDR_OUT) {
30060                 ndr_print_struct(ndr, "out", "spoolss_61");
30061                 ndr->depth++;
30062                 ndr_print_WERROR(ndr, "result", r->out.result);
30063                 ndr->depth--;
30064         }
30065         ndr->depth--;
30066 }
30067
30068 static enum ndr_err_code ndr_push_spoolss_62(struct ndr_push *ndr, int flags, const struct spoolss_62 *r)
30069 {
30070         if (flags & NDR_IN) {
30071         }
30072         if (flags & NDR_OUT) {
30073                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30074         }
30075         return NDR_ERR_SUCCESS;
30076 }
30077
30078 static enum ndr_err_code ndr_pull_spoolss_62(struct ndr_pull *ndr, int flags, struct spoolss_62 *r)
30079 {
30080         if (flags & NDR_IN) {
30081         }
30082         if (flags & NDR_OUT) {
30083                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30084         }
30085         return NDR_ERR_SUCCESS;
30086 }
30087
30088 _PUBLIC_ void ndr_print_spoolss_62(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_62 *r)
30089 {
30090         ndr_print_struct(ndr, name, "spoolss_62");
30091         ndr->depth++;
30092         if (flags & NDR_SET_VALUES) {
30093                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30094         }
30095         if (flags & NDR_IN) {
30096                 ndr_print_struct(ndr, "in", "spoolss_62");
30097                 ndr->depth++;
30098                 ndr->depth--;
30099         }
30100         if (flags & NDR_OUT) {
30101                 ndr_print_struct(ndr, "out", "spoolss_62");
30102                 ndr->depth++;
30103                 ndr_print_WERROR(ndr, "result", r->out.result);
30104                 ndr->depth--;
30105         }
30106         ndr->depth--;
30107 }
30108
30109 static enum ndr_err_code ndr_push_spoolss_63(struct ndr_push *ndr, int flags, const struct spoolss_63 *r)
30110 {
30111         if (flags & NDR_IN) {
30112         }
30113         if (flags & NDR_OUT) {
30114                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30115         }
30116         return NDR_ERR_SUCCESS;
30117 }
30118
30119 static enum ndr_err_code ndr_pull_spoolss_63(struct ndr_pull *ndr, int flags, struct spoolss_63 *r)
30120 {
30121         if (flags & NDR_IN) {
30122         }
30123         if (flags & NDR_OUT) {
30124                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30125         }
30126         return NDR_ERR_SUCCESS;
30127 }
30128
30129 _PUBLIC_ void ndr_print_spoolss_63(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_63 *r)
30130 {
30131         ndr_print_struct(ndr, name, "spoolss_63");
30132         ndr->depth++;
30133         if (flags & NDR_SET_VALUES) {
30134                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30135         }
30136         if (flags & NDR_IN) {
30137                 ndr_print_struct(ndr, "in", "spoolss_63");
30138                 ndr->depth++;
30139                 ndr->depth--;
30140         }
30141         if (flags & NDR_OUT) {
30142                 ndr_print_struct(ndr, "out", "spoolss_63");
30143                 ndr->depth++;
30144                 ndr_print_WERROR(ndr, "result", r->out.result);
30145                 ndr->depth--;
30146         }
30147         ndr->depth--;
30148 }
30149
30150 static enum ndr_err_code ndr_push_spoolss_64(struct ndr_push *ndr, int flags, const struct spoolss_64 *r)
30151 {
30152         if (flags & NDR_IN) {
30153         }
30154         if (flags & NDR_OUT) {
30155                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30156         }
30157         return NDR_ERR_SUCCESS;
30158 }
30159
30160 static enum ndr_err_code ndr_pull_spoolss_64(struct ndr_pull *ndr, int flags, struct spoolss_64 *r)
30161 {
30162         if (flags & NDR_IN) {
30163         }
30164         if (flags & NDR_OUT) {
30165                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30166         }
30167         return NDR_ERR_SUCCESS;
30168 }
30169
30170 _PUBLIC_ void ndr_print_spoolss_64(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_64 *r)
30171 {
30172         ndr_print_struct(ndr, name, "spoolss_64");
30173         ndr->depth++;
30174         if (flags & NDR_SET_VALUES) {
30175                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30176         }
30177         if (flags & NDR_IN) {
30178                 ndr_print_struct(ndr, "in", "spoolss_64");
30179                 ndr->depth++;
30180                 ndr->depth--;
30181         }
30182         if (flags & NDR_OUT) {
30183                 ndr_print_struct(ndr, "out", "spoolss_64");
30184                 ndr->depth++;
30185                 ndr_print_WERROR(ndr, "result", r->out.result);
30186                 ndr->depth--;
30187         }
30188         ndr->depth--;
30189 }
30190
30191 static enum ndr_err_code ndr_push_spoolss_65(struct ndr_push *ndr, int flags, const struct spoolss_65 *r)
30192 {
30193         if (flags & NDR_IN) {
30194         }
30195         if (flags & NDR_OUT) {
30196                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30197         }
30198         return NDR_ERR_SUCCESS;
30199 }
30200
30201 static enum ndr_err_code ndr_pull_spoolss_65(struct ndr_pull *ndr, int flags, struct spoolss_65 *r)
30202 {
30203         if (flags & NDR_IN) {
30204         }
30205         if (flags & NDR_OUT) {
30206                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30207         }
30208         return NDR_ERR_SUCCESS;
30209 }
30210
30211 _PUBLIC_ void ndr_print_spoolss_65(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_65 *r)
30212 {
30213         ndr_print_struct(ndr, name, "spoolss_65");
30214         ndr->depth++;
30215         if (flags & NDR_SET_VALUES) {
30216                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30217         }
30218         if (flags & NDR_IN) {
30219                 ndr_print_struct(ndr, "in", "spoolss_65");
30220                 ndr->depth++;
30221                 ndr->depth--;
30222         }
30223         if (flags & NDR_OUT) {
30224                 ndr_print_struct(ndr, "out", "spoolss_65");
30225                 ndr->depth++;
30226                 ndr_print_WERROR(ndr, "result", r->out.result);
30227                 ndr->depth--;
30228         }
30229         ndr->depth--;
30230 }
30231
30232 static enum ndr_err_code ndr_push_spoolss_GetCorePrinterDrivers(struct ndr_push *ndr, int flags, const struct spoolss_GetCorePrinterDrivers *r)
30233 {
30234         uint32_t cntr_core_printer_drivers_1;
30235         if (flags & NDR_IN) {
30236                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
30237                 if (r->in.servername) {
30238                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
30239                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30240                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
30241                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30242                 }
30243                 if (r->in.architecture == NULL) {
30244                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30245                 }
30246                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
30247                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30248                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
30249                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_driver_size));
30251                 if (r->in.core_driver_dependencies == NULL) {
30252                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30253                 }
30254                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_driver_size));
30255                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.core_driver_dependencies, r->in.core_driver_size, sizeof(uint16_t), CH_UTF16));
30256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
30257         }
30258         if (flags & NDR_OUT) {
30259                 if (r->out.core_printer_drivers == NULL) {
30260                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30261                 }
30262                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
30263                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
30264                         NDR_CHECK(ndr_push_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
30265                 }
30266                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30267         }
30268         return NDR_ERR_SUCCESS;
30269 }
30270
30271 static enum ndr_err_code ndr_pull_spoolss_GetCorePrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_GetCorePrinterDrivers *r)
30272 {
30273         uint32_t _ptr_servername;
30274         uint32_t cntr_core_printer_drivers_1;
30275         TALLOC_CTX *_mem_save_servername_0;
30276         TALLOC_CTX *_mem_save_core_printer_drivers_1;
30277         if (flags & NDR_IN) {
30278                 ZERO_STRUCT(r->out);
30279
30280                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
30281                 if (_ptr_servername) {
30282                         NDR_PULL_ALLOC(ndr, r->in.servername);
30283                 } else {
30284                         r->in.servername = NULL;
30285                 }
30286                 if (r->in.servername) {
30287                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
30288                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
30289                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
30290                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
30291                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
30292                                 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));
30293                         }
30294                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
30295                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
30296                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
30297                 }
30298                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
30299                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
30300                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
30301                         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));
30302                 }
30303                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
30304                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
30305                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_driver_size));
30306                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.core_driver_dependencies));
30307                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.core_driver_dependencies, ndr_get_array_size(ndr, &r->in.core_driver_dependencies), sizeof(uint16_t), CH_UTF16));
30308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_printer_driver_count));
30309                 NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, r->in.core_printer_driver_count);
30310                 memset(r->out.core_printer_drivers, 0, (r->in.core_printer_driver_count) * sizeof(*r->out.core_printer_drivers));
30311                 if (r->in.core_driver_dependencies) {
30312                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.core_driver_dependencies, r->in.core_driver_size));
30313                 }
30314         }
30315         if (flags & NDR_OUT) {
30316                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.core_printer_drivers));
30317                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
30318                         NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, ndr_get_array_size(ndr, &r->out.core_printer_drivers));
30319                 }
30320                 _mem_save_core_printer_drivers_1 = NDR_PULL_GET_MEM_CTX(ndr);
30321                 NDR_PULL_SET_MEM_CTX(ndr, r->out.core_printer_drivers, 0);
30322                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
30323                         NDR_CHECK(ndr_pull_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
30324                 }
30325                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_printer_drivers_1, 0);
30326                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30327                 if (r->out.core_printer_drivers) {
30328                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.core_printer_drivers, r->in.core_printer_driver_count));
30329                 }
30330         }
30331         return NDR_ERR_SUCCESS;
30332 }
30333
30334 _PUBLIC_ void ndr_print_spoolss_GetCorePrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetCorePrinterDrivers *r)
30335 {
30336         uint32_t cntr_core_printer_drivers_1;
30337         ndr_print_struct(ndr, name, "spoolss_GetCorePrinterDrivers");
30338         ndr->depth++;
30339         if (flags & NDR_SET_VALUES) {
30340                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30341         }
30342         if (flags & NDR_IN) {
30343                 ndr_print_struct(ndr, "in", "spoolss_GetCorePrinterDrivers");
30344                 ndr->depth++;
30345                 ndr_print_ptr(ndr, "servername", r->in.servername);
30346                 ndr->depth++;
30347                 if (r->in.servername) {
30348                         ndr_print_string(ndr, "servername", r->in.servername);
30349                 }
30350                 ndr->depth--;
30351                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
30352                 ndr->depth++;
30353                 ndr_print_string(ndr, "architecture", r->in.architecture);
30354                 ndr->depth--;
30355                 ndr_print_uint32(ndr, "core_driver_size", r->in.core_driver_size);
30356                 ndr_print_ptr(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
30357                 ndr->depth++;
30358                 ndr_print_string(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
30359                 ndr->depth--;
30360                 ndr_print_uint32(ndr, "core_printer_driver_count", r->in.core_printer_driver_count);
30361                 ndr->depth--;
30362         }
30363         if (flags & NDR_OUT) {
30364                 ndr_print_struct(ndr, "out", "spoolss_GetCorePrinterDrivers");
30365                 ndr->depth++;
30366                 ndr_print_ptr(ndr, "core_printer_drivers", r->out.core_printer_drivers);
30367                 ndr->depth++;
30368                 ndr->print(ndr, "%s: ARRAY(%d)", "core_printer_drivers", (int)r->in.core_printer_driver_count);
30369                 ndr->depth++;
30370                 for (cntr_core_printer_drivers_1=0;cntr_core_printer_drivers_1<r->in.core_printer_driver_count;cntr_core_printer_drivers_1++) {
30371                         char *idx_1=NULL;
30372                         if (asprintf(&idx_1, "[%d]", cntr_core_printer_drivers_1) != -1) {
30373                                 ndr_print_spoolss_CorePrinterDriver(ndr, "core_printer_drivers", &r->out.core_printer_drivers[cntr_core_printer_drivers_1]);
30374                                 free(idx_1);
30375                         }
30376                 }
30377                 ndr->depth--;
30378                 ndr->depth--;
30379                 ndr_print_WERROR(ndr, "result", r->out.result);
30380                 ndr->depth--;
30381         }
30382         ndr->depth--;
30383 }
30384
30385 static enum ndr_err_code ndr_push_spoolss_67(struct ndr_push *ndr, int flags, const struct spoolss_67 *r)
30386 {
30387         if (flags & NDR_IN) {
30388         }
30389         if (flags & NDR_OUT) {
30390                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30391         }
30392         return NDR_ERR_SUCCESS;
30393 }
30394
30395 static enum ndr_err_code ndr_pull_spoolss_67(struct ndr_pull *ndr, int flags, struct spoolss_67 *r)
30396 {
30397         if (flags & NDR_IN) {
30398         }
30399         if (flags & NDR_OUT) {
30400                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30401         }
30402         return NDR_ERR_SUCCESS;
30403 }
30404
30405 _PUBLIC_ void ndr_print_spoolss_67(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_67 *r)
30406 {
30407         ndr_print_struct(ndr, name, "spoolss_67");
30408         ndr->depth++;
30409         if (flags & NDR_SET_VALUES) {
30410                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30411         }
30412         if (flags & NDR_IN) {
30413                 ndr_print_struct(ndr, "in", "spoolss_67");
30414                 ndr->depth++;
30415                 ndr->depth--;
30416         }
30417         if (flags & NDR_OUT) {
30418                 ndr_print_struct(ndr, "out", "spoolss_67");
30419                 ndr->depth++;
30420                 ndr_print_WERROR(ndr, "result", r->out.result);
30421                 ndr->depth--;
30422         }
30423         ndr->depth--;
30424 }
30425
30426 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriverPackagePath(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
30427 {
30428         if (flags & NDR_IN) {
30429                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
30430                 if (r->in.servername) {
30431                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
30432                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30433                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
30434                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30435                 }
30436                 if (r->in.architecture == NULL) {
30437                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30438                 }
30439                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
30440                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30441                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
30442                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30443                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.language));
30444                 if (r->in.language) {
30445                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
30446                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30447                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
30448                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.language, ndr_charset_length(r->in.language, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30449                 }
30450                 if (r->in.package_id == NULL) {
30451                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30452                 }
30453                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
30454                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30455                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
30456                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.package_id, ndr_charset_length(r->in.package_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30457                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.driver_package_cab));
30458                 if (r->in.driver_package_cab) {
30459                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
30460                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
30461                 }
30462                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
30463         }
30464         if (flags & NDR_OUT) {
30465                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.driver_package_cab));
30466                 if (r->out.driver_package_cab) {
30467                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
30468                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
30469                 }
30470                 if (r->out.required == NULL) {
30471                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30472                 }
30473                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.required));
30474                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30475         }
30476         return NDR_ERR_SUCCESS;
30477 }
30478
30479 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverPackagePath(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverPackagePath *r)
30480 {
30481         uint32_t _ptr_servername;
30482         uint32_t _ptr_language;
30483         uint32_t _ptr_driver_package_cab;
30484         TALLOC_CTX *_mem_save_servername_0;
30485         TALLOC_CTX *_mem_save_language_0;
30486         TALLOC_CTX *_mem_save_driver_package_cab_0;
30487         TALLOC_CTX *_mem_save_required_0;
30488         if (flags & NDR_IN) {
30489                 ZERO_STRUCT(r->out);
30490
30491                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
30492                 if (_ptr_servername) {
30493                         NDR_PULL_ALLOC(ndr, r->in.servername);
30494                 } else {
30495                         r->in.servername = NULL;
30496                 }
30497                 if (r->in.servername) {
30498                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
30499                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
30500                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
30501                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
30502                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
30503                                 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));
30504                         }
30505                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
30506                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
30507                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
30508                 }
30509                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
30510                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
30511                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
30512                         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));
30513                 }
30514                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
30515                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
30516                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_language));
30517                 if (_ptr_language) {
30518                         NDR_PULL_ALLOC(ndr, r->in.language);
30519                 } else {
30520                         r->in.language = NULL;
30521                 }
30522                 if (r->in.language) {
30523                         _mem_save_language_0 = NDR_PULL_GET_MEM_CTX(ndr);
30524                         NDR_PULL_SET_MEM_CTX(ndr, r->in.language, 0);
30525                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.language));
30526                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.language));
30527                         if (ndr_get_array_length(ndr, &r->in.language) > ndr_get_array_size(ndr, &r->in.language)) {
30528                                 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.language), ndr_get_array_length(ndr, &r->in.language));
30529                         }
30530                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t)));
30531                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.language, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t), CH_UTF16));
30532                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_language_0, 0);
30533                 }
30534                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.package_id));
30535                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.package_id));
30536                 if (ndr_get_array_length(ndr, &r->in.package_id) > ndr_get_array_size(ndr, &r->in.package_id)) {
30537                         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.package_id), ndr_get_array_length(ndr, &r->in.package_id));
30538                 }
30539                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.package_id), sizeof(uint16_t)));
30540                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.package_id, ndr_get_array_length(ndr, &r->in.package_id), sizeof(uint16_t), CH_UTF16));
30541                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
30542                 if (_ptr_driver_package_cab) {
30543                         NDR_PULL_ALLOC(ndr, r->in.driver_package_cab);
30544                 } else {
30545                         r->in.driver_package_cab = NULL;
30546                 }
30547                 if (r->in.driver_package_cab) {
30548                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
30549                         NDR_PULL_SET_MEM_CTX(ndr, r->in.driver_package_cab, 0);
30550                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver_package_cab));
30551                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver_package_cab, ndr_get_array_size(ndr, &r->in.driver_package_cab), sizeof(uint16_t), CH_UTF16));
30552                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
30553                 }
30554                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.driver_package_cab_size));
30555                 NDR_PULL_ALLOC(ndr, r->out.required);
30556                 ZERO_STRUCTP(r->out.required);
30557                 if (r->in.driver_package_cab) {
30558                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.driver_package_cab, r->in.driver_package_cab_size));
30559                 }
30560         }
30561         if (flags & NDR_OUT) {
30562                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
30563                 if (_ptr_driver_package_cab) {
30564                         NDR_PULL_ALLOC(ndr, r->out.driver_package_cab);
30565                 } else {
30566                         r->out.driver_package_cab = NULL;
30567                 }
30568                 if (r->out.driver_package_cab) {
30569                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
30570                         NDR_PULL_SET_MEM_CTX(ndr, r->out.driver_package_cab, 0);
30571                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.driver_package_cab));
30572                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->out.driver_package_cab, ndr_get_array_size(ndr, &r->out.driver_package_cab), sizeof(uint16_t), CH_UTF16));
30573                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
30574                 }
30575                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
30576                         NDR_PULL_ALLOC(ndr, r->out.required);
30577                 }
30578                 _mem_save_required_0 = NDR_PULL_GET_MEM_CTX(ndr);
30579                 NDR_PULL_SET_MEM_CTX(ndr, r->out.required, LIBNDR_FLAG_REF_ALLOC);
30580                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.required));
30581                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_required_0, LIBNDR_FLAG_REF_ALLOC);
30582                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30583                 if (r->out.driver_package_cab) {
30584                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.driver_package_cab, r->in.driver_package_cab_size));
30585                 }
30586         }
30587         return NDR_ERR_SUCCESS;
30588 }
30589
30590 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverPackagePath(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
30591 {
30592         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverPackagePath");
30593         ndr->depth++;
30594         if (flags & NDR_SET_VALUES) {
30595                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30596         }
30597         if (flags & NDR_IN) {
30598                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverPackagePath");
30599                 ndr->depth++;
30600                 ndr_print_ptr(ndr, "servername", r->in.servername);
30601                 ndr->depth++;
30602                 if (r->in.servername) {
30603                         ndr_print_string(ndr, "servername", r->in.servername);
30604                 }
30605                 ndr->depth--;
30606                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
30607                 ndr->depth++;
30608                 ndr_print_string(ndr, "architecture", r->in.architecture);
30609                 ndr->depth--;
30610                 ndr_print_ptr(ndr, "language", r->in.language);
30611                 ndr->depth++;
30612                 if (r->in.language) {
30613                         ndr_print_string(ndr, "language", r->in.language);
30614                 }
30615                 ndr->depth--;
30616                 ndr_print_ptr(ndr, "package_id", r->in.package_id);
30617                 ndr->depth++;
30618                 ndr_print_string(ndr, "package_id", r->in.package_id);
30619                 ndr->depth--;
30620                 ndr_print_ptr(ndr, "driver_package_cab", r->in.driver_package_cab);
30621                 ndr->depth++;
30622                 if (r->in.driver_package_cab) {
30623                         ndr_print_string(ndr, "driver_package_cab", r->in.driver_package_cab);
30624                 }
30625                 ndr->depth--;
30626                 ndr_print_uint32(ndr, "driver_package_cab_size", r->in.driver_package_cab_size);
30627                 ndr->depth--;
30628         }
30629         if (flags & NDR_OUT) {
30630                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverPackagePath");
30631                 ndr->depth++;
30632                 ndr_print_ptr(ndr, "driver_package_cab", r->out.driver_package_cab);
30633                 ndr->depth++;
30634                 if (r->out.driver_package_cab) {
30635                         ndr_print_string(ndr, "driver_package_cab", r->out.driver_package_cab);
30636                 }
30637                 ndr->depth--;
30638                 ndr_print_ptr(ndr, "required", r->out.required);
30639                 ndr->depth++;
30640                 ndr_print_uint32(ndr, "required", *r->out.required);
30641                 ndr->depth--;
30642                 ndr_print_WERROR(ndr, "result", r->out.result);
30643                 ndr->depth--;
30644         }
30645         ndr->depth--;
30646 }
30647
30648 static enum ndr_err_code ndr_push_spoolss_69(struct ndr_push *ndr, int flags, const struct spoolss_69 *r)
30649 {
30650         if (flags & NDR_IN) {
30651         }
30652         if (flags & NDR_OUT) {
30653                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30654         }
30655         return NDR_ERR_SUCCESS;
30656 }
30657
30658 static enum ndr_err_code ndr_pull_spoolss_69(struct ndr_pull *ndr, int flags, struct spoolss_69 *r)
30659 {
30660         if (flags & NDR_IN) {
30661         }
30662         if (flags & NDR_OUT) {
30663                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30664         }
30665         return NDR_ERR_SUCCESS;
30666 }
30667
30668 _PUBLIC_ void ndr_print_spoolss_69(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_69 *r)
30669 {
30670         ndr_print_struct(ndr, name, "spoolss_69");
30671         ndr->depth++;
30672         if (flags & NDR_SET_VALUES) {
30673                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30674         }
30675         if (flags & NDR_IN) {
30676                 ndr_print_struct(ndr, "in", "spoolss_69");
30677                 ndr->depth++;
30678                 ndr->depth--;
30679         }
30680         if (flags & NDR_OUT) {
30681                 ndr_print_struct(ndr, "out", "spoolss_69");
30682                 ndr->depth++;
30683                 ndr_print_WERROR(ndr, "result", r->out.result);
30684                 ndr->depth--;
30685         }
30686         ndr->depth--;
30687 }
30688
30689 static enum ndr_err_code ndr_push_spoolss_6a(struct ndr_push *ndr, int flags, const struct spoolss_6a *r)
30690 {
30691         if (flags & NDR_IN) {
30692         }
30693         if (flags & NDR_OUT) {
30694                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30695         }
30696         return NDR_ERR_SUCCESS;
30697 }
30698
30699 static enum ndr_err_code ndr_pull_spoolss_6a(struct ndr_pull *ndr, int flags, struct spoolss_6a *r)
30700 {
30701         if (flags & NDR_IN) {
30702         }
30703         if (flags & NDR_OUT) {
30704                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30705         }
30706         return NDR_ERR_SUCCESS;
30707 }
30708
30709 _PUBLIC_ void ndr_print_spoolss_6a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6a *r)
30710 {
30711         ndr_print_struct(ndr, name, "spoolss_6a");
30712         ndr->depth++;
30713         if (flags & NDR_SET_VALUES) {
30714                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30715         }
30716         if (flags & NDR_IN) {
30717                 ndr_print_struct(ndr, "in", "spoolss_6a");
30718                 ndr->depth++;
30719                 ndr->depth--;
30720         }
30721         if (flags & NDR_OUT) {
30722                 ndr_print_struct(ndr, "out", "spoolss_6a");
30723                 ndr->depth++;
30724                 ndr_print_WERROR(ndr, "result", r->out.result);
30725                 ndr->depth--;
30726         }
30727         ndr->depth--;
30728 }
30729
30730 static enum ndr_err_code ndr_push_spoolss_6b(struct ndr_push *ndr, int flags, const struct spoolss_6b *r)
30731 {
30732         if (flags & NDR_IN) {
30733         }
30734         if (flags & NDR_OUT) {
30735                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30736         }
30737         return NDR_ERR_SUCCESS;
30738 }
30739
30740 static enum ndr_err_code ndr_pull_spoolss_6b(struct ndr_pull *ndr, int flags, struct spoolss_6b *r)
30741 {
30742         if (flags & NDR_IN) {
30743         }
30744         if (flags & NDR_OUT) {
30745                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30746         }
30747         return NDR_ERR_SUCCESS;
30748 }
30749
30750 _PUBLIC_ void ndr_print_spoolss_6b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6b *r)
30751 {
30752         ndr_print_struct(ndr, name, "spoolss_6b");
30753         ndr->depth++;
30754         if (flags & NDR_SET_VALUES) {
30755                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30756         }
30757         if (flags & NDR_IN) {
30758                 ndr_print_struct(ndr, "in", "spoolss_6b");
30759                 ndr->depth++;
30760                 ndr->depth--;
30761         }
30762         if (flags & NDR_OUT) {
30763                 ndr_print_struct(ndr, "out", "spoolss_6b");
30764                 ndr->depth++;
30765                 ndr_print_WERROR(ndr, "result", r->out.result);
30766                 ndr->depth--;
30767         }
30768         ndr->depth--;
30769 }
30770
30771 static enum ndr_err_code ndr_push_spoolss_6c(struct ndr_push *ndr, int flags, const struct spoolss_6c *r)
30772 {
30773         if (flags & NDR_IN) {
30774         }
30775         if (flags & NDR_OUT) {
30776                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30777         }
30778         return NDR_ERR_SUCCESS;
30779 }
30780
30781 static enum ndr_err_code ndr_pull_spoolss_6c(struct ndr_pull *ndr, int flags, struct spoolss_6c *r)
30782 {
30783         if (flags & NDR_IN) {
30784         }
30785         if (flags & NDR_OUT) {
30786                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30787         }
30788         return NDR_ERR_SUCCESS;
30789 }
30790
30791 _PUBLIC_ void ndr_print_spoolss_6c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6c *r)
30792 {
30793         ndr_print_struct(ndr, name, "spoolss_6c");
30794         ndr->depth++;
30795         if (flags & NDR_SET_VALUES) {
30796                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30797         }
30798         if (flags & NDR_IN) {
30799                 ndr_print_struct(ndr, "in", "spoolss_6c");
30800                 ndr->depth++;
30801                 ndr->depth--;
30802         }
30803         if (flags & NDR_OUT) {
30804                 ndr_print_struct(ndr, "out", "spoolss_6c");
30805                 ndr->depth++;
30806                 ndr_print_WERROR(ndr, "result", r->out.result);
30807                 ndr->depth--;
30808         }
30809         ndr->depth--;
30810 }
30811
30812 static enum ndr_err_code ndr_push_spoolss_6d(struct ndr_push *ndr, int flags, const struct spoolss_6d *r)
30813 {
30814         if (flags & NDR_IN) {
30815         }
30816         if (flags & NDR_OUT) {
30817                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30818         }
30819         return NDR_ERR_SUCCESS;
30820 }
30821
30822 static enum ndr_err_code ndr_pull_spoolss_6d(struct ndr_pull *ndr, int flags, struct spoolss_6d *r)
30823 {
30824         if (flags & NDR_IN) {
30825         }
30826         if (flags & NDR_OUT) {
30827                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30828         }
30829         return NDR_ERR_SUCCESS;
30830 }
30831
30832 _PUBLIC_ void ndr_print_spoolss_6d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6d *r)
30833 {
30834         ndr_print_struct(ndr, name, "spoolss_6d");
30835         ndr->depth++;
30836         if (flags & NDR_SET_VALUES) {
30837                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30838         }
30839         if (flags & NDR_IN) {
30840                 ndr_print_struct(ndr, "in", "spoolss_6d");
30841                 ndr->depth++;
30842                 ndr->depth--;
30843         }
30844         if (flags & NDR_OUT) {
30845                 ndr_print_struct(ndr, "out", "spoolss_6d");
30846                 ndr->depth++;
30847                 ndr_print_WERROR(ndr, "result", r->out.result);
30848                 ndr->depth--;
30849         }
30850         ndr->depth--;
30851 }
30852
30853 static const struct ndr_interface_call spoolss_calls[] = {
30854         {
30855                 "spoolss_EnumPrinters",
30856                 sizeof(struct spoolss_EnumPrinters),
30857                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
30858                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
30859                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
30860                 false,
30861         },
30862         {
30863                 "spoolss_OpenPrinter",
30864                 sizeof(struct spoolss_OpenPrinter),
30865                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
30866                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
30867                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
30868                 false,
30869         },
30870         {
30871                 "spoolss_SetJob",
30872                 sizeof(struct spoolss_SetJob),
30873                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
30874                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
30875                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
30876                 false,
30877         },
30878         {
30879                 "spoolss_GetJob",
30880                 sizeof(struct spoolss_GetJob),
30881                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
30882                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
30883                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
30884                 false,
30885         },
30886         {
30887                 "spoolss_EnumJobs",
30888                 sizeof(struct spoolss_EnumJobs),
30889                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
30890                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
30891                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
30892                 false,
30893         },
30894         {
30895                 "spoolss_AddPrinter",
30896                 sizeof(struct spoolss_AddPrinter),
30897                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
30898                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
30899                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
30900                 false,
30901         },
30902         {
30903                 "spoolss_DeletePrinter",
30904                 sizeof(struct spoolss_DeletePrinter),
30905                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
30906                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
30907                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
30908                 false,
30909         },
30910         {
30911                 "spoolss_SetPrinter",
30912                 sizeof(struct spoolss_SetPrinter),
30913                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
30914                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
30915                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
30916                 false,
30917         },
30918         {
30919                 "spoolss_GetPrinter",
30920                 sizeof(struct spoolss_GetPrinter),
30921                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
30922                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
30923                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
30924                 false,
30925         },
30926         {
30927                 "spoolss_AddPrinterDriver",
30928                 sizeof(struct spoolss_AddPrinterDriver),
30929                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
30930                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
30931                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
30932                 false,
30933         },
30934         {
30935                 "spoolss_EnumPrinterDrivers",
30936                 sizeof(struct spoolss_EnumPrinterDrivers),
30937                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
30938                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
30939                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
30940                 false,
30941         },
30942         {
30943                 "spoolss_GetPrinterDriver",
30944                 sizeof(struct spoolss_GetPrinterDriver),
30945                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
30946                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
30947                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
30948                 false,
30949         },
30950         {
30951                 "spoolss_GetPrinterDriverDirectory",
30952                 sizeof(struct spoolss_GetPrinterDriverDirectory),
30953                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
30954                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
30955                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
30956                 false,
30957         },
30958         {
30959                 "spoolss_DeletePrinterDriver",
30960                 sizeof(struct spoolss_DeletePrinterDriver),
30961                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
30962                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
30963                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
30964                 false,
30965         },
30966         {
30967                 "spoolss_AddPrintProcessor",
30968                 sizeof(struct spoolss_AddPrintProcessor),
30969                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
30970                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
30971                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
30972                 false,
30973         },
30974         {
30975                 "spoolss_EnumPrintProcessors",
30976                 sizeof(struct spoolss_EnumPrintProcessors),
30977                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
30978                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
30979                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
30980                 false,
30981         },
30982         {
30983                 "spoolss_GetPrintProcessorDirectory",
30984                 sizeof(struct spoolss_GetPrintProcessorDirectory),
30985                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
30986                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
30987                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
30988                 false,
30989         },
30990         {
30991                 "spoolss_StartDocPrinter",
30992                 sizeof(struct spoolss_StartDocPrinter),
30993                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
30994                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
30995                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
30996                 false,
30997         },
30998         {
30999                 "spoolss_StartPagePrinter",
31000                 sizeof(struct spoolss_StartPagePrinter),
31001                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
31002                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
31003                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
31004                 false,
31005         },
31006         {
31007                 "spoolss_WritePrinter",
31008                 sizeof(struct spoolss_WritePrinter),
31009                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
31010                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
31011                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
31012                 false,
31013         },
31014         {
31015                 "spoolss_EndPagePrinter",
31016                 sizeof(struct spoolss_EndPagePrinter),
31017                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
31018                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
31019                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
31020                 false,
31021         },
31022         {
31023                 "spoolss_AbortPrinter",
31024                 sizeof(struct spoolss_AbortPrinter),
31025                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
31026                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
31027                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
31028                 false,
31029         },
31030         {
31031                 "spoolss_ReadPrinter",
31032                 sizeof(struct spoolss_ReadPrinter),
31033                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
31034                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
31035                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
31036                 false,
31037         },
31038         {
31039                 "spoolss_EndDocPrinter",
31040                 sizeof(struct spoolss_EndDocPrinter),
31041                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
31042                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
31043                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
31044                 false,
31045         },
31046         {
31047                 "spoolss_AddJob",
31048                 sizeof(struct spoolss_AddJob),
31049                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
31050                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
31051                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
31052                 false,
31053         },
31054         {
31055                 "spoolss_ScheduleJob",
31056                 sizeof(struct spoolss_ScheduleJob),
31057                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
31058                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
31059                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
31060                 false,
31061         },
31062         {
31063                 "spoolss_GetPrinterData",
31064                 sizeof(struct spoolss_GetPrinterData),
31065                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
31066                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
31067                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
31068                 false,
31069         },
31070         {
31071                 "spoolss_SetPrinterData",
31072                 sizeof(struct spoolss_SetPrinterData),
31073                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
31074                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
31075                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
31076                 false,
31077         },
31078         {
31079                 "spoolss_WaitForPrinterChange",
31080                 sizeof(struct spoolss_WaitForPrinterChange),
31081                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
31082                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
31083                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
31084                 false,
31085         },
31086         {
31087                 "spoolss_ClosePrinter",
31088                 sizeof(struct spoolss_ClosePrinter),
31089                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
31090                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
31091                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
31092                 false,
31093         },
31094         {
31095                 "spoolss_AddForm",
31096                 sizeof(struct spoolss_AddForm),
31097                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
31098                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
31099                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
31100                 false,
31101         },
31102         {
31103                 "spoolss_DeleteForm",
31104                 sizeof(struct spoolss_DeleteForm),
31105                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
31106                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
31107                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
31108                 false,
31109         },
31110         {
31111                 "spoolss_GetForm",
31112                 sizeof(struct spoolss_GetForm),
31113                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
31114                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
31115                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
31116                 false,
31117         },
31118         {
31119                 "spoolss_SetForm",
31120                 sizeof(struct spoolss_SetForm),
31121                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
31122                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
31123                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
31124                 false,
31125         },
31126         {
31127                 "spoolss_EnumForms",
31128                 sizeof(struct spoolss_EnumForms),
31129                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
31130                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
31131                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
31132                 false,
31133         },
31134         {
31135                 "spoolss_EnumPorts",
31136                 sizeof(struct spoolss_EnumPorts),
31137                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
31138                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
31139                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
31140                 false,
31141         },
31142         {
31143                 "spoolss_EnumMonitors",
31144                 sizeof(struct spoolss_EnumMonitors),
31145                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
31146                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
31147                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
31148                 false,
31149         },
31150         {
31151                 "spoolss_AddPort",
31152                 sizeof(struct spoolss_AddPort),
31153                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
31154                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
31155                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
31156                 false,
31157         },
31158         {
31159                 "spoolss_ConfigurePort",
31160                 sizeof(struct spoolss_ConfigurePort),
31161                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
31162                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
31163                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
31164                 false,
31165         },
31166         {
31167                 "spoolss_DeletePort",
31168                 sizeof(struct spoolss_DeletePort),
31169                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
31170                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
31171                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
31172                 false,
31173         },
31174         {
31175                 "spoolss_CreatePrinterIC",
31176                 sizeof(struct spoolss_CreatePrinterIC),
31177                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
31178                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
31179                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
31180                 false,
31181         },
31182         {
31183                 "spoolss_PlayGDIScriptOnPrinterIC",
31184                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
31185                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
31186                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
31187                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
31188                 false,
31189         },
31190         {
31191                 "spoolss_DeletePrinterIC",
31192                 sizeof(struct spoolss_DeletePrinterIC),
31193                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
31194                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
31195                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
31196                 false,
31197         },
31198         {
31199                 "spoolss_AddPrinterConnection",
31200                 sizeof(struct spoolss_AddPrinterConnection),
31201                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
31202                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
31203                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
31204                 false,
31205         },
31206         {
31207                 "spoolss_DeletePrinterConnection",
31208                 sizeof(struct spoolss_DeletePrinterConnection),
31209                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
31210                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
31211                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
31212                 false,
31213         },
31214         {
31215                 "spoolss_PrinterMessageBox",
31216                 sizeof(struct spoolss_PrinterMessageBox),
31217                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
31218                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
31219                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
31220                 false,
31221         },
31222         {
31223                 "spoolss_AddMonitor",
31224                 sizeof(struct spoolss_AddMonitor),
31225                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
31226                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
31227                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
31228                 false,
31229         },
31230         {
31231                 "spoolss_DeleteMonitor",
31232                 sizeof(struct spoolss_DeleteMonitor),
31233                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
31234                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
31235                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
31236                 false,
31237         },
31238         {
31239                 "spoolss_DeletePrintProcessor",
31240                 sizeof(struct spoolss_DeletePrintProcessor),
31241                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
31242                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
31243                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
31244                 false,
31245         },
31246         {
31247                 "spoolss_AddPrintProvidor",
31248                 sizeof(struct spoolss_AddPrintProvidor),
31249                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
31250                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
31251                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
31252                 false,
31253         },
31254         {
31255                 "spoolss_DeletePrintProvidor",
31256                 sizeof(struct spoolss_DeletePrintProvidor),
31257                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
31258                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
31259                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
31260                 false,
31261         },
31262         {
31263                 "spoolss_EnumPrintProcDataTypes",
31264                 sizeof(struct spoolss_EnumPrintProcDataTypes),
31265                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
31266                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
31267                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
31268                 false,
31269         },
31270         {
31271                 "spoolss_ResetPrinter",
31272                 sizeof(struct spoolss_ResetPrinter),
31273                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
31274                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
31275                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
31276                 false,
31277         },
31278         {
31279                 "spoolss_GetPrinterDriver2",
31280                 sizeof(struct spoolss_GetPrinterDriver2),
31281                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
31282                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
31283                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
31284                 false,
31285         },
31286         {
31287                 "spoolss_FindFirstPrinterChangeNotification",
31288                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
31289                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
31290                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
31291                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
31292                 false,
31293         },
31294         {
31295                 "spoolss_FindNextPrinterChangeNotification",
31296                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
31297                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
31298                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
31299                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
31300                 false,
31301         },
31302         {
31303                 "spoolss_FindClosePrinterNotify",
31304                 sizeof(struct spoolss_FindClosePrinterNotify),
31305                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
31306                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
31307                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
31308                 false,
31309         },
31310         {
31311                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
31312                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
31313                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
31314                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
31315                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
31316                 false,
31317         },
31318         {
31319                 "spoolss_ReplyOpenPrinter",
31320                 sizeof(struct spoolss_ReplyOpenPrinter),
31321                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
31322                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
31323                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
31324                 false,
31325         },
31326         {
31327                 "spoolss_RouterReplyPrinter",
31328                 sizeof(struct spoolss_RouterReplyPrinter),
31329                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
31330                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
31331                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
31332                 false,
31333         },
31334         {
31335                 "spoolss_ReplyClosePrinter",
31336                 sizeof(struct spoolss_ReplyClosePrinter),
31337                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
31338                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
31339                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
31340                 false,
31341         },
31342         {
31343                 "spoolss_AddPortEx",
31344                 sizeof(struct spoolss_AddPortEx),
31345                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
31346                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
31347                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
31348                 false,
31349         },
31350         {
31351                 "spoolss_RouterFindFirstPrinterChangeNotification",
31352                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
31353                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
31354                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
31355                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
31356                 false,
31357         },
31358         {
31359                 "spoolss_SpoolerInit",
31360                 sizeof(struct spoolss_SpoolerInit),
31361                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
31362                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
31363                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
31364                 false,
31365         },
31366         {
31367                 "spoolss_ResetPrinterEx",
31368                 sizeof(struct spoolss_ResetPrinterEx),
31369                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
31370                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
31371                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
31372                 false,
31373         },
31374         {
31375                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
31376                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
31377                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
31378                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
31379                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
31380                 false,
31381         },
31382         {
31383                 "spoolss_RouterReplyPrinterEx",
31384                 sizeof(struct spoolss_RouterReplyPrinterEx),
31385                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
31386                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
31387                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
31388                 false,
31389         },
31390         {
31391                 "spoolss_RouterRefreshPrinterChangeNotify",
31392                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
31393                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
31394                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
31395                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
31396                 false,
31397         },
31398         {
31399                 "spoolss_44",
31400                 sizeof(struct spoolss_44),
31401                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
31402                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
31403                 (ndr_print_function_t) ndr_print_spoolss_44,
31404                 false,
31405         },
31406         {
31407                 "spoolss_OpenPrinterEx",
31408                 sizeof(struct spoolss_OpenPrinterEx),
31409                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
31410                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
31411                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
31412                 false,
31413         },
31414         {
31415                 "spoolss_AddPrinterEx",
31416                 sizeof(struct spoolss_AddPrinterEx),
31417                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
31418                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
31419                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
31420                 false,
31421         },
31422         {
31423                 "spoolss_47",
31424                 sizeof(struct spoolss_47),
31425                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
31426                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
31427                 (ndr_print_function_t) ndr_print_spoolss_47,
31428                 false,
31429         },
31430         {
31431                 "spoolss_EnumPrinterData",
31432                 sizeof(struct spoolss_EnumPrinterData),
31433                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
31434                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
31435                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
31436                 false,
31437         },
31438         {
31439                 "spoolss_DeletePrinterData",
31440                 sizeof(struct spoolss_DeletePrinterData),
31441                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
31442                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
31443                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
31444                 false,
31445         },
31446         {
31447                 "spoolss_4a",
31448                 sizeof(struct spoolss_4a),
31449                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
31450                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
31451                 (ndr_print_function_t) ndr_print_spoolss_4a,
31452                 false,
31453         },
31454         {
31455                 "spoolss_4b",
31456                 sizeof(struct spoolss_4b),
31457                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
31458                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
31459                 (ndr_print_function_t) ndr_print_spoolss_4b,
31460                 false,
31461         },
31462         {
31463                 "spoolss_4c",
31464                 sizeof(struct spoolss_4c),
31465                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
31466                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
31467                 (ndr_print_function_t) ndr_print_spoolss_4c,
31468                 false,
31469         },
31470         {
31471                 "spoolss_SetPrinterDataEx",
31472                 sizeof(struct spoolss_SetPrinterDataEx),
31473                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
31474                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
31475                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
31476                 false,
31477         },
31478         {
31479                 "spoolss_GetPrinterDataEx",
31480                 sizeof(struct spoolss_GetPrinterDataEx),
31481                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
31482                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
31483                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
31484                 false,
31485         },
31486         {
31487                 "spoolss_EnumPrinterDataEx",
31488                 sizeof(struct spoolss_EnumPrinterDataEx),
31489                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
31490                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
31491                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
31492                 false,
31493         },
31494         {
31495                 "spoolss_EnumPrinterKey",
31496                 sizeof(struct spoolss_EnumPrinterKey),
31497                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
31498                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
31499                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
31500                 false,
31501         },
31502         {
31503                 "spoolss_DeletePrinterDataEx",
31504                 sizeof(struct spoolss_DeletePrinterDataEx),
31505                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
31506                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
31507                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
31508                 false,
31509         },
31510         {
31511                 "spoolss_DeletePrinterKey",
31512                 sizeof(struct spoolss_DeletePrinterKey),
31513                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
31514                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
31515                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
31516                 false,
31517         },
31518         {
31519                 "spoolss_53",
31520                 sizeof(struct spoolss_53),
31521                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
31522                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
31523                 (ndr_print_function_t) ndr_print_spoolss_53,
31524                 false,
31525         },
31526         {
31527                 "spoolss_DeletePrinterDriverEx",
31528                 sizeof(struct spoolss_DeletePrinterDriverEx),
31529                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
31530                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
31531                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
31532                 false,
31533         },
31534         {
31535                 "spoolss_55",
31536                 sizeof(struct spoolss_55),
31537                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
31538                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
31539                 (ndr_print_function_t) ndr_print_spoolss_55,
31540                 false,
31541         },
31542         {
31543                 "spoolss_56",
31544                 sizeof(struct spoolss_56),
31545                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
31546                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
31547                 (ndr_print_function_t) ndr_print_spoolss_56,
31548                 false,
31549         },
31550         {
31551                 "spoolss_57",
31552                 sizeof(struct spoolss_57),
31553                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
31554                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
31555                 (ndr_print_function_t) ndr_print_spoolss_57,
31556                 false,
31557         },
31558         {
31559                 "spoolss_XcvData",
31560                 sizeof(struct spoolss_XcvData),
31561                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
31562                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
31563                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
31564                 false,
31565         },
31566         {
31567                 "spoolss_AddPrinterDriverEx",
31568                 sizeof(struct spoolss_AddPrinterDriverEx),
31569                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
31570                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
31571                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
31572                 false,
31573         },
31574         {
31575                 "spoolss_5a",
31576                 sizeof(struct spoolss_5a),
31577                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
31578                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
31579                 (ndr_print_function_t) ndr_print_spoolss_5a,
31580                 false,
31581         },
31582         {
31583                 "spoolss_5b",
31584                 sizeof(struct spoolss_5b),
31585                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
31586                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
31587                 (ndr_print_function_t) ndr_print_spoolss_5b,
31588                 false,
31589         },
31590         {
31591                 "spoolss_5c",
31592                 sizeof(struct spoolss_5c),
31593                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
31594                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
31595                 (ndr_print_function_t) ndr_print_spoolss_5c,
31596                 false,
31597         },
31598         {
31599                 "spoolss_5d",
31600                 sizeof(struct spoolss_5d),
31601                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
31602                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
31603                 (ndr_print_function_t) ndr_print_spoolss_5d,
31604                 false,
31605         },
31606         {
31607                 "spoolss_5e",
31608                 sizeof(struct spoolss_5e),
31609                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
31610                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
31611                 (ndr_print_function_t) ndr_print_spoolss_5e,
31612                 false,
31613         },
31614         {
31615                 "spoolss_5f",
31616                 sizeof(struct spoolss_5f),
31617                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
31618                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
31619                 (ndr_print_function_t) ndr_print_spoolss_5f,
31620                 false,
31621         },
31622         {
31623                 "spoolss_60",
31624                 sizeof(struct spoolss_60),
31625                 (ndr_push_flags_fn_t) ndr_push_spoolss_60,
31626                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_60,
31627                 (ndr_print_function_t) ndr_print_spoolss_60,
31628                 false,
31629         },
31630         {
31631                 "spoolss_61",
31632                 sizeof(struct spoolss_61),
31633                 (ndr_push_flags_fn_t) ndr_push_spoolss_61,
31634                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_61,
31635                 (ndr_print_function_t) ndr_print_spoolss_61,
31636                 false,
31637         },
31638         {
31639                 "spoolss_62",
31640                 sizeof(struct spoolss_62),
31641                 (ndr_push_flags_fn_t) ndr_push_spoolss_62,
31642                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_62,
31643                 (ndr_print_function_t) ndr_print_spoolss_62,
31644                 false,
31645         },
31646         {
31647                 "spoolss_63",
31648                 sizeof(struct spoolss_63),
31649                 (ndr_push_flags_fn_t) ndr_push_spoolss_63,
31650                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_63,
31651                 (ndr_print_function_t) ndr_print_spoolss_63,
31652                 false,
31653         },
31654         {
31655                 "spoolss_64",
31656                 sizeof(struct spoolss_64),
31657                 (ndr_push_flags_fn_t) ndr_push_spoolss_64,
31658                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_64,
31659                 (ndr_print_function_t) ndr_print_spoolss_64,
31660                 false,
31661         },
31662         {
31663                 "spoolss_65",
31664                 sizeof(struct spoolss_65),
31665                 (ndr_push_flags_fn_t) ndr_push_spoolss_65,
31666                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_65,
31667                 (ndr_print_function_t) ndr_print_spoolss_65,
31668                 false,
31669         },
31670         {
31671                 "spoolss_GetCorePrinterDrivers",
31672                 sizeof(struct spoolss_GetCorePrinterDrivers),
31673                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetCorePrinterDrivers,
31674                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetCorePrinterDrivers,
31675                 (ndr_print_function_t) ndr_print_spoolss_GetCorePrinterDrivers,
31676                 false,
31677         },
31678         {
31679                 "spoolss_67",
31680                 sizeof(struct spoolss_67),
31681                 (ndr_push_flags_fn_t) ndr_push_spoolss_67,
31682                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_67,
31683                 (ndr_print_function_t) ndr_print_spoolss_67,
31684                 false,
31685         },
31686         {
31687                 "spoolss_GetPrinterDriverPackagePath",
31688                 sizeof(struct spoolss_GetPrinterDriverPackagePath),
31689                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverPackagePath,
31690                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverPackagePath,
31691                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverPackagePath,
31692                 false,
31693         },
31694         {
31695                 "spoolss_69",
31696                 sizeof(struct spoolss_69),
31697                 (ndr_push_flags_fn_t) ndr_push_spoolss_69,
31698                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_69,
31699                 (ndr_print_function_t) ndr_print_spoolss_69,
31700                 false,
31701         },
31702         {
31703                 "spoolss_6a",
31704                 sizeof(struct spoolss_6a),
31705                 (ndr_push_flags_fn_t) ndr_push_spoolss_6a,
31706                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6a,
31707                 (ndr_print_function_t) ndr_print_spoolss_6a,
31708                 false,
31709         },
31710         {
31711                 "spoolss_6b",
31712                 sizeof(struct spoolss_6b),
31713                 (ndr_push_flags_fn_t) ndr_push_spoolss_6b,
31714                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6b,
31715                 (ndr_print_function_t) ndr_print_spoolss_6b,
31716                 false,
31717         },
31718         {
31719                 "spoolss_6c",
31720                 sizeof(struct spoolss_6c),
31721                 (ndr_push_flags_fn_t) ndr_push_spoolss_6c,
31722                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6c,
31723                 (ndr_print_function_t) ndr_print_spoolss_6c,
31724                 false,
31725         },
31726         {
31727                 "spoolss_6d",
31728                 sizeof(struct spoolss_6d),
31729                 (ndr_push_flags_fn_t) ndr_push_spoolss_6d,
31730                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6d,
31731                 (ndr_print_function_t) ndr_print_spoolss_6d,
31732                 false,
31733         },
31734         { NULL, 0, NULL, NULL, NULL, false }
31735 };
31736
31737 static const char * const spoolss_endpoint_strings[] = {
31738         "ncacn_np:[\\pipe\\spoolss]",
31739 };
31740
31741 static const struct ndr_interface_string_array spoolss_endpoints = {
31742         .count  = 1,
31743         .names  = spoolss_endpoint_strings
31744 };
31745
31746 static const char * const spoolss_authservice_strings[] = {
31747         "host",
31748 };
31749
31750 static const struct ndr_interface_string_array spoolss_authservices = {
31751         .count  = 1,
31752         .names  = spoolss_authservice_strings
31753 };
31754
31755
31756 const struct ndr_interface_table ndr_table_spoolss = {
31757         .name           = "spoolss",
31758         .syntax_id      = {
31759                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
31760                 NDR_SPOOLSS_VERSION
31761         },
31762         .helpstring     = NDR_SPOOLSS_HELPSTRING,
31763         .num_calls      = 110,
31764         .calls          = spoolss_calls,
31765         .endpoints      = &spoolss_endpoints,
31766         .authservices   = &spoolss_authservices
31767 };
31768