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 static 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 static 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(ndr, r->printername));
 362                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 363                         }
 364                         ndr->flags = _flags_save_string;
 365                 }
 366                 {
 367                         uint32_t _flags_save_string = ndr->flags;
 368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 369                         if (r->servername) {
 370                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 371                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 372                         }
 373                         ndr->flags = _flags_save_string;
 374                 }
 375         }
 376         return NDR_ERR_SUCCESS;
 377 }
 378
 379 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 380 {
 381         uint32_t _ptr_printername;
 382         TALLOC_CTX *_mem_save_printername_0;
 383         uint32_t _ptr_servername;
 384         TALLOC_CTX *_mem_save_servername_0;
 385         if (ndr_flags & NDR_SCALARS) {
 386                 NDR_CHECK(ndr_pull_align(ndr, 5));
 387                 {
 388                         uint32_t _flags_save_string = ndr->flags;
 389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 390                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 391                         if (_ptr_printername) {
 392                                 NDR_PULL_ALLOC(ndr, r->printername);
 393                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 394                         } else {
 395                                 r->printername = NULL;
 396                         }
 397                         ndr->flags = _flags_save_string;
 398                 }
 399                 {
 400                         uint32_t _flags_save_string = ndr->flags;
 401                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 402                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 403                         if (_ptr_servername) {
 404                                 NDR_PULL_ALLOC(ndr, r->servername);
 405                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 406                         } else {
 407                                 r->servername = NULL;
 408                         }
 409                         ndr->flags = _flags_save_string;
 410                 }
 411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 414                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 424                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 426                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 428                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 429                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 430                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 433                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 434                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 435                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 438                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 439         }
 440         if (ndr_flags & NDR_BUFFERS) {
 441                 {
 442                         uint32_t _flags_save_string = ndr->flags;
 443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 444                         if (r->printername) {
 445                                 uint32_t _relative_save_offset;
 446                                 _relative_save_offset = ndr->offset;
 447                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 448                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 449                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 450                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 451                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 452                                 if (ndr->offset > ndr->relative_highest_offset) {
 453                                         ndr->relative_highest_offset = ndr->offset;
 454                                 }
 455                                 ndr->offset = _relative_save_offset;
 456                         }
 457                         ndr->flags = _flags_save_string;
 458                 }
 459                 {
 460                         uint32_t _flags_save_string = ndr->flags;
 461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 462                         if (r->servername) {
 463                                 uint32_t _relative_save_offset;
 464                                 _relative_save_offset = ndr->offset;
 465                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 466                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 467                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 468                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 469                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 470                                 if (ndr->offset > ndr->relative_highest_offset) {
 471                                         ndr->relative_highest_offset = ndr->offset;
 472                                 }
 473                                 ndr->offset = _relative_save_offset;
 474                         }
 475                         ndr->flags = _flags_save_string;
 476                 }
 477         }
 478         return NDR_ERR_SUCCESS;
 479 }
 480
 481 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 482 {
 483         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 484         ndr->depth++;
 485         ndr_print_ptr(ndr, "printername", r->printername);
 486         ndr->depth++;
 487         if (r->printername) {
 488                 ndr_print_string(ndr, "printername", r->printername);
 489         }
 490         ndr->depth--;
 491         ndr_print_ptr(ndr, "servername", r->servername);
 492         ndr->depth++;
 493         if (r->servername) {
 494                 ndr_print_string(ndr, "servername", r->servername);
 495         }
 496         ndr->depth--;
 497         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 498         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 499         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 500         ndr_print_spoolss_Time(ndr, "time", &r->time);
 501         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 502         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 503         ndr_print_uint32(ndr, "version", r->version);
 504         ndr_print_uint32(ndr, "free_build", r->free_build);
 505         ndr_print_uint32(ndr, "spooling", r->spooling);
 506         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 507         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 508         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 509         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 510         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 511         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 512         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 513         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 514         ndr_print_uint32(ndr, "change_id", r->change_id);
 515         ndr_print_WERROR(ndr, "last_error", r->last_error);
 516         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 517         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 518         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 519         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 520         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 521         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 522         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 523         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 524         ndr->depth--;
 525 }
 526
 527 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo0(const struct spoolss_PrinterInfo0 *r, struct smb_iconv_convenience *ic, int flags)
 528 {
 529         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo0, ic);
 530 }
 531
 532 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 533 {
 534         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 535         return NDR_ERR_SUCCESS;
 536 }
 537
 538 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 539 {
 540         uint32_t v;
 541         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 542         *r = v;
 543         return NDR_ERR_SUCCESS;
 544 }
 545
 546 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 547 {
 548         ndr_print_uint32(ndr, name, r);
 549         ndr->depth++;
 550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 561         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 562         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 563         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 564         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 565         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 566         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 567         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 568         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 569         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 570         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 571         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 572         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 573         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 574         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 575         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 576         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 577         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 578         ndr->depth--;
 579 }
 580
 581 static enum ndr_err_code ndr_push_spoolss_DeviceModeSpecVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion r)
 582 {
 583         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 584         return NDR_ERR_SUCCESS;
 585 }
 586
 587 static enum ndr_err_code ndr_pull_spoolss_DeviceModeSpecVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion *r)
 588 {
 589         uint16_t v;
 590         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 591         *r = v;
 592         return NDR_ERR_SUCCESS;
 593 }
 594
 595 _PUBLIC_ void ndr_print_spoolss_DeviceModeSpecVersion(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeSpecVersion r)
 596 {
 597         const char *val = NULL;
 598
 599         switch (r) {
 600                 case DMSPEC_NT3: val = "DMSPEC_NT3"; break;
 601                 case DMSPEC_WIN95_98_ME: val = "DMSPEC_WIN95_98_ME"; break;
 602                 case DMSPEC_NT4_AND_ABOVE: val = "DMSPEC_NT4_AND_ABOVE"; break;
 603         }
 604         ndr_print_enum(ndr, name, "ENUM", val, r);
 605 }
 606
 607 static enum ndr_err_code ndr_push_spoolss_DeviceModeOrientation(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation r)
 608 {
 609         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 610         return NDR_ERR_SUCCESS;
 611 }
 612
 613 static enum ndr_err_code ndr_pull_spoolss_DeviceModeOrientation(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation *r)
 614 {
 615         uint16_t v;
 616         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 617         *r = v;
 618         return NDR_ERR_SUCCESS;
 619 }
 620
 621 _PUBLIC_ void ndr_print_spoolss_DeviceModeOrientation(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeOrientation r)
 622 {
 623         const char *val = NULL;
 624
 625         switch (r) {
 626                 case DMORIENT_PORTRAIT: val = "DMORIENT_PORTRAIT"; break;
 627                 case DMORIENT_LANDSCAPE: val = "DMORIENT_LANDSCAPE"; break;
 628         }
 629         ndr_print_enum(ndr, name, "ENUM", val, r);
 630 }
 631
 632 static enum ndr_err_code ndr_push_spoolss_DeviceModePaperSize(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize r)
 633 {
 634         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 635         return NDR_ERR_SUCCESS;
 636 }
 637
 638 static enum ndr_err_code ndr_pull_spoolss_DeviceModePaperSize(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize *r)
 639 {
 640         uint16_t v;
 641         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 642         *r = v;
 643         return NDR_ERR_SUCCESS;
 644 }
 645
 646 _PUBLIC_ void ndr_print_spoolss_DeviceModePaperSize(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePaperSize r)
 647 {
 648         const char *val = NULL;
 649
 650         switch (r) {
 651                 case DMPAPER_LETTER: val = "DMPAPER_LETTER"; break;
 652                 case DMPAPER_LETTERSMALL: val = "DMPAPER_LETTERSMALL"; break;
 653                 case DMPAPER_TABLOID: val = "DMPAPER_TABLOID"; break;
 654                 case DMPAPER_LEDGER: val = "DMPAPER_LEDGER"; break;
 655                 case DMPAPER_LEGAL: val = "DMPAPER_LEGAL"; break;
 656                 case DMPAPER_STATEMENT: val = "DMPAPER_STATEMENT"; break;
 657                 case DMPAPER_EXECUTIVE: val = "DMPAPER_EXECUTIVE"; break;
 658                 case DMPAPER_A3: val = "DMPAPER_A3"; break;
 659                 case DMPAPER_A4: val = "DMPAPER_A4"; break;
 660                 case DMPAPER_A4SMALL: val = "DMPAPER_A4SMALL"; break;
 661                 case DMPAPER_A5: val = "DMPAPER_A5"; break;
 662                 case DMPAPER_B4: val = "DMPAPER_B4"; break;
 663                 case DMPAPER_B5: val = "DMPAPER_B5"; break;
 664                 case DMPAPER_FOLIO: val = "DMPAPER_FOLIO"; break;
 665                 case DMPAPER_QUARTO: val = "DMPAPER_QUARTO"; break;
 666                 case DMPAPER_10X14: val = "DMPAPER_10X14"; break;
 667                 case DMPAPER_11X17: val = "DMPAPER_11X17"; break;
 668                 case DMPAPER_NOTE: val = "DMPAPER_NOTE"; break;
 669                 case DMPAPER_ENV_9: val = "DMPAPER_ENV_9"; break;
 670                 case DMPAPER_ENV_10: val = "DMPAPER_ENV_10"; break;
 671                 case DMPAPER_ENV_11: val = "DMPAPER_ENV_11"; break;
 672                 case DMPAPER_ENV_12: val = "DMPAPER_ENV_12"; break;
 673                 case DMPAPER_ENV_14: val = "DMPAPER_ENV_14"; break;
 674                 case DMPAPER_CSHEET: val = "DMPAPER_CSHEET"; break;
 675                 case DMPAPER_DSHEET: val = "DMPAPER_DSHEET"; break;
 676                 case DMPAPER_ESHEET: val = "DMPAPER_ESHEET"; break;
 677                 case DMPAPER_ENV_DL: val = "DMPAPER_ENV_DL"; break;
 678                 case DMPAPER_ENV_C5: val = "DMPAPER_ENV_C5"; break;
 679                 case DMPAPER_ENV_C3: val = "DMPAPER_ENV_C3"; break;
 680                 case DMPAPER_ENV_C4: val = "DMPAPER_ENV_C4"; break;
 681                 case DMPAPER_ENV_C6: val = "DMPAPER_ENV_C6"; break;
 682                 case DMPAPER_ENV_C65: val = "DMPAPER_ENV_C65"; break;
 683                 case DMPAPER_ENV_B4: val = "DMPAPER_ENV_B4"; break;
 684                 case DMPAPER_ENV_B5: val = "DMPAPER_ENV_B5"; break;
 685                 case DMPAPER_ENV_B6: val = "DMPAPER_ENV_B6"; break;
 686                 case DMPAPER_ENV_ITALY: val = "DMPAPER_ENV_ITALY"; break;
 687                 case DMPAPER_ENV_MONARCH: val = "DMPAPER_ENV_MONARCH"; break;
 688                 case DMPAPER_ENV_PERSONAL: val = "DMPAPER_ENV_PERSONAL"; break;
 689                 case DMPAPER_FANFOLD_US: val = "DMPAPER_FANFOLD_US"; break;
 690                 case DMPAPER_FANFOLD_STD_GERMAN: val = "DMPAPER_FANFOLD_STD_GERMAN"; break;
 691                 case DMPAPER_FANFOLD_LGL_GERMAN: val = "DMPAPER_FANFOLD_LGL_GERMAN"; break;
 692                 case DMPAPER_DBL_JAPANESE_POSTCARD: val = "DMPAPER_DBL_JAPANESE_POSTCARD"; break;
 693                 case DMPAPER_A6: val = "DMPAPER_A6"; break;
 694                 case DMPAPER_JENV_KAKU2: val = "DMPAPER_JENV_KAKU2"; break;
 695                 case DMPAPER_JENV_KAKU3: val = "DMPAPER_JENV_KAKU3"; break;
 696                 case DMPAPER_JENV_CHOU3: val = "DMPAPER_JENV_CHOU3"; break;
 697                 case DMPAPER_JENV_CHOU4: val = "DMPAPER_JENV_CHOU4"; break;
 698                 case DMPAPER_LETTER_ROTATED: val = "DMPAPER_LETTER_ROTATED"; break;
 699                 case DMPAPER_A3_ROTATED: val = "DMPAPER_A3_ROTATED"; break;
 700                 case DMPAPER_A4_ROTATED: val = "DMPAPER_A4_ROTATED"; break;
 701                 case DMPAPER_A5_ROTATED: val = "DMPAPER_A5_ROTATED"; break;
 702                 case DMPAPER_B4_JIS_ROTATED: val = "DMPAPER_B4_JIS_ROTATED"; break;
 703                 case DMPAPER_B5_JIS_ROTATED: val = "DMPAPER_B5_JIS_ROTATED"; break;
 704                 case DMPAPER_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_JAPANESE_POSTCARD_ROTATED"; break;
 705                 case DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED"; break;
 706                 case DMPAPER_A6_ROTATED: val = "DMPAPER_A6_ROTATED"; break;
 707                 case DMPAPER_JENV_KAKU2_ROTATED: val = "DMPAPER_JENV_KAKU2_ROTATED"; break;
 708                 case DMPAPER_JENV_KAKU3_ROTATED: val = "DMPAPER_JENV_KAKU3_ROTATED"; break;
 709                 case DMPAPER_JENV_CHOU3_ROTATED: val = "DMPAPER_JENV_CHOU3_ROTATED"; break;
 710                 case DMPAPER_JENV_CHOU4_ROTATED: val = "DMPAPER_JENV_CHOU4_ROTATED"; break;
 711                 case DMPAPER_B6_JIS: val = "DMPAPER_B6_JIS"; break;
 712                 case DMPAPER_B6_JIS_ROTATED: val = "DMPAPER_B6_JIS_ROTATED"; break;
 713                 case DMPAPER_12X11: val = "DMPAPER_12X11"; break;
 714                 case DMPAPER_JENV_YOU4: val = "DMPAPER_JENV_YOU4"; break;
 715                 case DMPAPER_JENV_YOU4_ROTATED: val = "DMPAPER_JENV_YOU4_ROTATED"; break;
 716                 case DMPAPER_P16K: val = "DMPAPER_P16K"; break;
 717                 case DMPAPER_P32K: val = "DMPAPER_P32K"; break;
 718                 case DMPAPER_P32KBIG: val = "DMPAPER_P32KBIG"; break;
 719                 case DMPAPER_PENV_1: val = "DMPAPER_PENV_1"; break;
 720                 case DMPAPER_PENV_2: val = "DMPAPER_PENV_2"; break;
 721                 case DMPAPER_PENV_3: val = "DMPAPER_PENV_3"; break;
 722                 case DMPAPER_PENV_4: val = "DMPAPER_PENV_4"; break;
 723                 case DMPAPER_PENV_5: val = "DMPAPER_PENV_5"; break;
 724                 case DMPAPER_PENV_6: val = "DMPAPER_PENV_6"; break;
 725                 case DMPAPER_PENV_7: val = "DMPAPER_PENV_7"; break;
 726                 case DMPAPER_PENV_8: val = "DMPAPER_PENV_8"; break;
 727                 case DMPAPER_PENV_9: val = "DMPAPER_PENV_9"; break;
 728                 case DMPAPER_PENV_10: val = "DMPAPER_PENV_10"; break;
 729                 case DMPAPER_P16K_ROTATED: val = "DMPAPER_P16K_ROTATED"; break;
 730                 case DMPAPER_P32K_ROTATED: val = "DMPAPER_P32K_ROTATED"; break;
 731                 case DMPAPER_P32KBIG_ROTATED: val = "DMPAPER_P32KBIG_ROTATED"; break;
 732                 case DMPAPER_PENV_1_ROTATED: val = "DMPAPER_PENV_1_ROTATED"; break;
 733                 case DMPAPER_PENV_2_ROTATED: val = "DMPAPER_PENV_2_ROTATED"; break;
 734                 case DMPAPER_PENV_3_ROTATED: val = "DMPAPER_PENV_3_ROTATED"; break;
 735                 case DMPAPER_PENV_4_ROTATED: val = "DMPAPER_PENV_4_ROTATED"; break;
 736                 case DMPAPER_PENV_5_ROTATED: val = "DMPAPER_PENV_5_ROTATED"; break;
 737                 case DMPAPER_PENV_6_ROTATED: val = "DMPAPER_PENV_6_ROTATED"; break;
 738                 case DMPAPER_PENV_7_ROTATED: val = "DMPAPER_PENV_7_ROTATED"; break;
 739                 case DMPAPER_PENV_8_ROTATED: val = "DMPAPER_PENV_8_ROTATED"; break;
 740                 case DMPAPER_PENV_9_ROTATED: val = "DMPAPER_PENV_9_ROTATED"; break;
 741                 case DMPAPER_PENV_10_ROTATED: val = "DMPAPER_PENV_10_ROTATED"; break;
 742         }
 743         ndr_print_enum(ndr, name, "ENUM", val, r);
 744 }
 745
 746 static enum ndr_err_code ndr_push_spoolss_DeviceModeDefaultSource(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource r)
 747 {
 748         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 749         return NDR_ERR_SUCCESS;
 750 }
 751
 752 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDefaultSource(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource *r)
 753 {
 754         uint16_t v;
 755         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 756         *r = v;
 757         return NDR_ERR_SUCCESS;
 758 }
 759
 760 _PUBLIC_ void ndr_print_spoolss_DeviceModeDefaultSource(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDefaultSource r)
 761 {
 762         const char *val = NULL;
 763
 764         switch (r) {
 765                 case DMBIN_UPPER: val = "DMBIN_UPPER"; break;
 766                 case DMBIN_LOWER: val = "DMBIN_LOWER"; break;
 767                 case DMBIN_MIDDLE: val = "DMBIN_MIDDLE"; break;
 768                 case DMBIN_MANUAL: val = "DMBIN_MANUAL"; break;
 769                 case DMBIN_ENVELOPE: val = "DMBIN_ENVELOPE"; break;
 770                 case DMBIN_ENVMANUAL: val = "DMBIN_ENVMANUAL"; break;
 771                 case DMBIN_AUTO: val = "DMBIN_AUTO"; break;
 772                 case DMBIN_TRACTOR: val = "DMBIN_TRACTOR"; break;
 773                 case DMBIN_SMALLFMT: val = "DMBIN_SMALLFMT"; break;
 774                 case DMBIN_LARGEFMT: val = "DMBIN_LARGEFMT"; break;
 775                 case DMBIN_LARGECAPACITY: val = "DMBIN_LARGECAPACITY"; break;
 776                 case DMBIN_CASSETTE: val = "DMBIN_CASSETTE"; break;
 777                 case DMBIN_FORMSOURCE: val = "DMBIN_FORMSOURCE"; break;
 778         }
 779         ndr_print_enum(ndr, name, "ENUM", val, r);
 780 }
 781
 782 static enum ndr_err_code ndr_push_spoolss_DeviceModePrintQuality(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality r)
 783 {
 784         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 785         return NDR_ERR_SUCCESS;
 786 }
 787
 788 static enum ndr_err_code ndr_pull_spoolss_DeviceModePrintQuality(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality *r)
 789 {
 790         uint16_t v;
 791         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 792         *r = v;
 793         return NDR_ERR_SUCCESS;
 794 }
 795
 796 _PUBLIC_ void ndr_print_spoolss_DeviceModePrintQuality(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePrintQuality r)
 797 {
 798         const char *val = NULL;
 799
 800         switch (r) {
 801                 case DMRES_HIGH: val = "DMRES_HIGH"; break;
 802                 case DMRES_MEDIUM: val = "DMRES_MEDIUM"; break;
 803                 case DMRES_LOW: val = "DMRES_LOW"; break;
 804                 case DMRES_DRAFT: val = "DMRES_DRAFT"; break;
 805         }
 806         ndr_print_enum(ndr, name, "ENUM", val, r);
 807 }
 808
 809 static enum ndr_err_code ndr_push_spoolss_DeviceModeColor(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeColor r)
 810 {
 811         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 812         return NDR_ERR_SUCCESS;
 813 }
 814
 815 static enum ndr_err_code ndr_pull_spoolss_DeviceModeColor(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeColor *r)
 816 {
 817         uint16_t v;
 818         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 819         *r = v;
 820         return NDR_ERR_SUCCESS;
 821 }
 822
 823 _PUBLIC_ void ndr_print_spoolss_DeviceModeColor(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeColor r)
 824 {
 825         const char *val = NULL;
 826
 827         switch (r) {
 828                 case DMRES_MONOCHROME: val = "DMRES_MONOCHROME"; break;
 829                 case DMRES_COLOR: val = "DMRES_COLOR"; break;
 830         }
 831         ndr_print_enum(ndr, name, "ENUM", val, r);
 832 }
 833
 834 static enum ndr_err_code ndr_push_spoolss_DeviceModeDuplex(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex r)
 835 {
 836         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 837         return NDR_ERR_SUCCESS;
 838 }
 839
 840 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDuplex(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex *r)
 841 {
 842         uint16_t v;
 843         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 844         *r = v;
 845         return NDR_ERR_SUCCESS;
 846 }
 847
 848 _PUBLIC_ void ndr_print_spoolss_DeviceModeDuplex(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDuplex r)
 849 {
 850         const char *val = NULL;
 851
 852         switch (r) {
 853                 case DMDUP_SIMPLEX: val = "DMDUP_SIMPLEX"; break;
 854                 case DMDUP_VERTICAL: val = "DMDUP_VERTICAL"; break;
 855                 case DMDUP_HORIZONTAL: val = "DMDUP_HORIZONTAL"; break;
 856         }
 857         ndr_print_enum(ndr, name, "ENUM", val, r);
 858 }
 859
 860 static enum ndr_err_code ndr_push_spoolss_DeviceModeTTOption(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption r)
 861 {
 862         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 863         return NDR_ERR_SUCCESS;
 864 }
 865
 866 static enum ndr_err_code ndr_pull_spoolss_DeviceModeTTOption(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption *r)
 867 {
 868         uint16_t v;
 869         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 870         *r = v;
 871         return NDR_ERR_SUCCESS;
 872 }
 873
 874 _PUBLIC_ void ndr_print_spoolss_DeviceModeTTOption(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeTTOption r)
 875 {
 876         const char *val = NULL;
 877
 878         switch (r) {
 879                 case DMTT_BITMAP: val = "DMTT_BITMAP"; break;
 880                 case DMTT_DOWNLOAD: val = "DMTT_DOWNLOAD"; break;
 881                 case DMTT_SUBDEV: val = "DMTT_SUBDEV"; break;
 882                 case DMTT_DOWNLOAD_OUTLINE: val = "DMTT_DOWNLOAD_OUTLINE"; break;
 883         }
 884         ndr_print_enum(ndr, name, "ENUM", val, r);
 885 }
 886
 887 static enum ndr_err_code ndr_push_spoolss_DeviceModeCollate(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeCollate r)
 888 {
 889         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 890         return NDR_ERR_SUCCESS;
 891 }
 892
 893 static enum ndr_err_code ndr_pull_spoolss_DeviceModeCollate(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeCollate *r)
 894 {
 895         uint16_t v;
 896         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 897         *r = v;
 898         return NDR_ERR_SUCCESS;
 899 }
 900
 901 _PUBLIC_ void ndr_print_spoolss_DeviceModeCollate(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeCollate r)
 902 {
 903         const char *val = NULL;
 904
 905         switch (r) {
 906                 case DMCOLLATE_FALSE: val = "DMCOLLATE_FALSE"; break;
 907                 case DMCOLLATE_TRUE: val = "DMCOLLATE_TRUE"; break;
 908         }
 909         ndr_print_enum(ndr, name, "ENUM", val, r);
 910 }
 911
 912 static enum ndr_err_code ndr_push_spoolss_DeviceModeNUp(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeNUp r)
 913 {
 914         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 915         return NDR_ERR_SUCCESS;
 916 }
 917
 918 static enum ndr_err_code ndr_pull_spoolss_DeviceModeNUp(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeNUp *r)
 919 {
 920         uint32_t v;
 921         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 922         *r = v;
 923         return NDR_ERR_SUCCESS;
 924 }
 925
 926 _PUBLIC_ void ndr_print_spoolss_DeviceModeNUp(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeNUp r)
 927 {
 928         const char *val = NULL;
 929
 930         switch (r) {
 931                 case DMNUP_SYSTEM: val = "DMNUP_SYSTEM"; break;
 932                 case DMNUP_ONEUP: val = "DMNUP_ONEUP"; break;
 933         }
 934         ndr_print_enum(ndr, name, "ENUM", val, r);
 935 }
 936
 937 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMMethod(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod r)
 938 {
 939         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 940         return NDR_ERR_SUCCESS;
 941 }
 942
 943 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMMethod(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod *r)
 944 {
 945         uint32_t v;
 946         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 947         *r = v;
 948         return NDR_ERR_SUCCESS;
 949 }
 950
 951 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMMethod(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMMethod r)
 952 {
 953         const char *val = NULL;
 954
 955         switch (r) {
 956                 case DMICMMETHOD_NONE: val = "DMICMMETHOD_NONE"; break;
 957                 case DMICMMETHOD_SYSTEM: val = "DMICMMETHOD_SYSTEM"; break;
 958                 case DMICMMETHOD_DRIVER: val = "DMICMMETHOD_DRIVER"; break;
 959                 case DMICMMETHOD_DEVICE: val = "DMICMMETHOD_DEVICE"; break;
 960         }
 961         ndr_print_enum(ndr, name, "ENUM", val, r);
 962 }
 963
 964 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMIntent(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent r)
 965 {
 966         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 967         return NDR_ERR_SUCCESS;
 968 }
 969
 970 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMIntent(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent *r)
 971 {
 972         uint32_t v;
 973         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 974         *r = v;
 975         return NDR_ERR_SUCCESS;
 976 }
 977
 978 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMIntent(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMIntent r)
 979 {
 980         const char *val = NULL;
 981
 982         switch (r) {
 983                 case DMICM_SATURATE: val = "DMICM_SATURATE"; break;
 984                 case DMICM_CONTRAST: val = "DMICM_CONTRAST"; break;
 985                 case DMICM_COLORIMETRIC: val = "DMICM_COLORIMETRIC"; break;
 986                 case DMICM_ABS_COLORIMETRIC: val = "DMICM_ABS_COLORIMETRIC"; break;
 987         }
 988         ndr_print_enum(ndr, name, "ENUM", val, r);
 989 }
 990
 991 static enum ndr_err_code ndr_push_spoolss_DeviceModeMediaType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType r)
 992 {
 993         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 994         return NDR_ERR_SUCCESS;
 995 }
 996
 997 static enum ndr_err_code ndr_pull_spoolss_DeviceModeMediaType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType *r)
 998 {
 999         uint32_t v;
1000         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1001         *r = v;
1002         return NDR_ERR_SUCCESS;
1003 }
1004
1005 _PUBLIC_ void ndr_print_spoolss_DeviceModeMediaType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeMediaType r)
1006 {
1007         const char *val = NULL;
1008
1009         switch (r) {
1010                 case DMMEDIA_STANDARD: val = "DMMEDIA_STANDARD"; break;
1011                 case DMMEDIA_TRANSPARENCY: val = "DMMEDIA_TRANSPARENCY"; break;
1012                 case DMMEDIA_GLOSSY: val = "DMMEDIA_GLOSSY"; break;
1013         }
1014         ndr_print_enum(ndr, name, "ENUM", val, r);
1015 }
1016
1017 static enum ndr_err_code ndr_push_spoolss_DeviceModeDitherType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType r)
1018 {
1019         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1020         return NDR_ERR_SUCCESS;
1021 }
1022
1023 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDitherType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType *r)
1024 {
1025         uint32_t v;
1026         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1027         *r = v;
1028         return NDR_ERR_SUCCESS;
1029 }
1030
1031 _PUBLIC_ void ndr_print_spoolss_DeviceModeDitherType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDitherType r)
1032 {
1033         const char *val = NULL;
1034
1035         switch (r) {
1036                 case DMDITHER_NONE: val = "DMDITHER_NONE"; break;
1037                 case DMDITHER_COARSE: val = "DMDITHER_COARSE"; break;
1038                 case DMDITHER_FINE: val = "DMDITHER_FINE"; break;
1039                 case DMDITHER_LINEART: val = "DMDITHER_LINEART"; break;
1040                 case DMDITHER_ERRORDIFFUSION: val = "DMDITHER_ERRORDIFFUSION"; break;
1041                 case DMDITHER_RESERVED6: val = "DMDITHER_RESERVED6"; break;
1042                 case DMDITHER_RESERVED7: val = "DMDITHER_RESERVED7"; break;
1043                 case DMDITHER_RESERVED8: val = "DMDITHER_RESERVED8"; break;
1044                 case DMDITHER_RESERVED9: val = "DMDITHER_RESERVED9"; break;
1045                 case DMDITHER_GRAYSCALE: val = "DMDITHER_GRAYSCALE"; break;
1046         }
1047         ndr_print_enum(ndr, name, "ENUM", val, r);
1048 }
1049
1050 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
1051 {
1052         if (ndr_flags & NDR_SCALARS) {
1053                 NDR_CHECK(ndr_push_align(ndr, 4));
1054                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1055                 NDR_CHECK(ndr_push_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, r->specversion));
1056                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
1057                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
1058                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
1059                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
1060                 NDR_CHECK(ndr_push_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, r->orientation));
1061                 NDR_CHECK(ndr_push_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, r->papersize));
1062                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
1063                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
1064                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
1065                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
1066                 NDR_CHECK(ndr_push_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, r->defaultsource));
1067                 NDR_CHECK(ndr_push_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, r->printquality));
1068                 NDR_CHECK(ndr_push_spoolss_DeviceModeColor(ndr, NDR_SCALARS, r->color));
1069                 NDR_CHECK(ndr_push_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, r->duplex));
1070                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
1071                 NDR_CHECK(ndr_push_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, r->ttoption));
1072                 NDR_CHECK(ndr_push_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, r->collate));
1073                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1074                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
1075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
1076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
1077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
1078                 NDR_CHECK(ndr_push_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, r->displayflags));
1079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
1080                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, r->icmmethod));
1081                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, r->icmintent));
1082                 NDR_CHECK(ndr_push_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, r->mediatype));
1083                 NDR_CHECK(ndr_push_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, r->dithertype));
1084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
1085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
1086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
1087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
1088                 {
1089                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1091                         {
1092                                 struct ndr_push *_ndr_driverextra_data;
1093                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
1094                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
1095                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
1096                         }
1097                         ndr->flags = _flags_save_DATA_BLOB;
1098                 }
1099                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1100         }
1101         if (ndr_flags & NDR_BUFFERS) {
1102         }
1103         return NDR_ERR_SUCCESS;
1104 }
1105
1106 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
1107 {
1108         if (ndr_flags & NDR_SCALARS) {
1109                 NDR_CHECK(ndr_pull_align(ndr, 4));
1110                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1111                 NDR_CHECK(ndr_pull_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, &r->specversion));
1112                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
1113                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
1114                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
1115                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
1116                 NDR_CHECK(ndr_pull_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, &r->orientation));
1117                 NDR_CHECK(ndr_pull_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, &r->papersize));
1118                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
1119                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
1120                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
1121                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
1122                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, &r->defaultsource));
1123                 NDR_CHECK(ndr_pull_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, &r->printquality));
1124                 NDR_CHECK(ndr_pull_spoolss_DeviceModeColor(ndr, NDR_SCALARS, &r->color));
1125                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, &r->duplex));
1126                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
1127                 NDR_CHECK(ndr_pull_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, &r->ttoption));
1128                 NDR_CHECK(ndr_pull_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, &r->collate));
1129                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1130                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
1131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
1132                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
1133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
1134                 NDR_CHECK(ndr_pull_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, &r->displayflags));
1135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
1136                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, &r->icmmethod));
1137                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, &r->icmintent));
1138                 NDR_CHECK(ndr_pull_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, &r->mediatype));
1139                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, &r->dithertype));
1140                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
1143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
1144                 {
1145                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1146                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1147                         {
1148                                 struct ndr_pull *_ndr_driverextra_data;
1149                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
1150                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
1151                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
1152                         }
1153                         ndr->flags = _flags_save_DATA_BLOB;
1154                 }
1155                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1156         }
1157         if (ndr_flags & NDR_BUFFERS) {
1158         }
1159         return NDR_ERR_SUCCESS;
1160 }
1161
1162 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
1163 {
1164         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
1165         ndr->depth++;
1166         ndr_print_string(ndr, "devicename", r->devicename);
1167         ndr_print_spoolss_DeviceModeSpecVersion(ndr, "specversion", r->specversion);
1168         ndr_print_uint16(ndr, "driverversion", r->driverversion);
1169         ndr_print_uint16(ndr, "size", r->size);
1170         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
1171         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
1172         ndr_print_spoolss_DeviceModeOrientation(ndr, "orientation", r->orientation);
1173         ndr_print_spoolss_DeviceModePaperSize(ndr, "papersize", r->papersize);
1174         ndr_print_uint16(ndr, "paperlength", r->paperlength);
1175         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
1176         ndr_print_uint16(ndr, "scale", r->scale);
1177         ndr_print_uint16(ndr, "copies", r->copies);
1178         ndr_print_spoolss_DeviceModeDefaultSource(ndr, "defaultsource", r->defaultsource);
1179         ndr_print_spoolss_DeviceModePrintQuality(ndr, "printquality", r->printquality);
1180         ndr_print_spoolss_DeviceModeColor(ndr, "color", r->color);
1181         ndr_print_spoolss_DeviceModeDuplex(ndr, "duplex", r->duplex);
1182         ndr_print_uint16(ndr, "yresolution", r->yresolution);
1183         ndr_print_spoolss_DeviceModeTTOption(ndr, "ttoption", r->ttoption);
1184         ndr_print_spoolss_DeviceModeCollate(ndr, "collate", r->collate);
1185         ndr_print_string(ndr, "formname", r->formname);
1186         ndr_print_uint16(ndr, "logpixels", r->logpixels);
1187         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
1188         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
1189         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
1190         ndr_print_spoolss_DeviceModeNUp(ndr, "displayflags", r->displayflags);
1191         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
1192         ndr_print_spoolss_DeviceModeICMMethod(ndr, "icmmethod", r->icmmethod);
1193         ndr_print_spoolss_DeviceModeICMIntent(ndr, "icmintent", r->icmintent);
1194         ndr_print_spoolss_DeviceModeMediaType(ndr, "mediatype", r->mediatype);
1195         ndr_print_spoolss_DeviceModeDitherType(ndr, "dithertype", r->dithertype);
1196         ndr_print_uint32(ndr, "reserved1", r->reserved1);
1197         ndr_print_uint32(ndr, "reserved2", r->reserved2);
1198         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
1199         ndr_print_uint32(ndr, "panningheight", r->panningheight);
1200         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
1201         ndr->depth--;
1202 }
1203
1204 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
1205 {
1206         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
1207 }
1208
1209 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1210 {
1211         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1212         return NDR_ERR_SUCCESS;
1213 }
1214
1215 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1216 {
1217         uint32_t v;
1218         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1219         *r = v;
1220         return NDR_ERR_SUCCESS;
1221 }
1222
1223 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
1224 {
1225         ndr_print_uint32(ndr, name, r);
1226         ndr->depth++;
1227         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
1228         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
1229         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
1230         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
1231         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
1232         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
1233         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
1234         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
1235         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
1236         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
1237         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
1238         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
1239         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
1240         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
1241         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
1242         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
1243         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
1244         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
1245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
1246         ndr->depth--;
1247 }
1248
1249 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1250 {
1251         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1252         return NDR_ERR_SUCCESS;
1253 }
1254
1255 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1256 {
1257         uint32_t v;
1258         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1259         *r = v;
1260         return NDR_ERR_SUCCESS;
1261 }
1262
1263 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
1264 {
1265         ndr_print_uint32(ndr, name, r);
1266         ndr->depth++;
1267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
1268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
1269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
1270         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
1271         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
1272         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
1273         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
1274         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
1275         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
1276         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
1277         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
1278         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
1279         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
1280         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
1281         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
1282         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
1283         ndr->depth--;
1284 }
1285
1286 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
1287 {
1288         if (ndr_flags & NDR_SCALARS) {
1289                 NDR_CHECK(ndr_push_align(ndr, 5));
1290                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
1291                 {
1292                         uint32_t _flags_save_string = ndr->flags;
1293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1294                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
1295                         ndr->flags = _flags_save_string;
1296                 }
1297                 {
1298                         uint32_t _flags_save_string = ndr->flags;
1299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1300                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
1301                         ndr->flags = _flags_save_string;
1302                 }
1303                 {
1304                         uint32_t _flags_save_string = ndr->flags;
1305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1306                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1307                         ndr->flags = _flags_save_string;
1308                 }
1309                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1310         }
1311         if (ndr_flags & NDR_BUFFERS) {
1312                 {
1313                         uint32_t _flags_save_string = ndr->flags;
1314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1315                         if (r->description) {
1316                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
1317                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
1318                         }
1319                         ndr->flags = _flags_save_string;
1320                 }
1321                 {
1322                         uint32_t _flags_save_string = ndr->flags;
1323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1324                         if (r->name) {
1325                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
1326                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
1327                         }
1328                         ndr->flags = _flags_save_string;
1329                 }
1330                 {
1331                         uint32_t _flags_save_string = ndr->flags;
1332                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1333                         if (r->comment) {
1334                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1335                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1336                         }
1337                         ndr->flags = _flags_save_string;
1338                 }
1339         }
1340         return NDR_ERR_SUCCESS;
1341 }
1342
1343 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
1344 {
1345         uint32_t _ptr_description;
1346         TALLOC_CTX *_mem_save_description_0;
1347         uint32_t _ptr_name;
1348         TALLOC_CTX *_mem_save_name_0;
1349         uint32_t _ptr_comment;
1350         TALLOC_CTX *_mem_save_comment_0;
1351         if (ndr_flags & NDR_SCALARS) {
1352                 NDR_CHECK(ndr_pull_align(ndr, 5));
1353                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
1354                 {
1355                         uint32_t _flags_save_string = ndr->flags;
1356                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1357                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
1358                         if (_ptr_description) {
1359                                 NDR_PULL_ALLOC(ndr, r->description);
1360                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
1361                         } else {
1362                                 r->description = NULL;
1363                         }
1364                         ndr->flags = _flags_save_string;
1365                 }
1366                 {
1367                         uint32_t _flags_save_string = ndr->flags;
1368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1369                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
1370                         if (_ptr_name) {
1371                                 NDR_PULL_ALLOC(ndr, r->name);
1372                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
1373                         } else {
1374                                 r->name = NULL;
1375                         }
1376                         ndr->flags = _flags_save_string;
1377                 }
1378                 {
1379                         uint32_t _flags_save_string = ndr->flags;
1380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1381                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1382                         if (_ptr_comment) {
1383                                 NDR_PULL_ALLOC(ndr, r->comment);
1384                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1385                         } else {
1386                                 r->comment = NULL;
1387                         }
1388                         ndr->flags = _flags_save_string;
1389                 }
1390                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1391         }
1392         if (ndr_flags & NDR_BUFFERS) {
1393                 {
1394                         uint32_t _flags_save_string = ndr->flags;
1395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1396                         if (r->description) {
1397                                 uint32_t _relative_save_offset;
1398                                 _relative_save_offset = ndr->offset;
1399                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
1400                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
1401                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
1402                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
1403                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
1404                                 if (ndr->offset > ndr->relative_highest_offset) {
1405                                         ndr->relative_highest_offset = ndr->offset;
1406                                 }
1407                                 ndr->offset = _relative_save_offset;
1408                         }
1409                         ndr->flags = _flags_save_string;
1410                 }
1411                 {
1412                         uint32_t _flags_save_string = ndr->flags;
1413                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1414                         if (r->name) {
1415                                 uint32_t _relative_save_offset;
1416                                 _relative_save_offset = ndr->offset;
1417                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
1418                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1419                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
1420                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
1421                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
1422                                 if (ndr->offset > ndr->relative_highest_offset) {
1423                                         ndr->relative_highest_offset = ndr->offset;
1424                                 }
1425                                 ndr->offset = _relative_save_offset;
1426                         }
1427                         ndr->flags = _flags_save_string;
1428                 }
1429                 {
1430                         uint32_t _flags_save_string = ndr->flags;
1431                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1432                         if (r->comment) {
1433                                 uint32_t _relative_save_offset;
1434                                 _relative_save_offset = ndr->offset;
1435                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1436                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1437                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1438                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1439                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1440                                 if (ndr->offset > ndr->relative_highest_offset) {
1441                                         ndr->relative_highest_offset = ndr->offset;
1442                                 }
1443                                 ndr->offset = _relative_save_offset;
1444                         }
1445                         ndr->flags = _flags_save_string;
1446                 }
1447         }
1448         return NDR_ERR_SUCCESS;
1449 }
1450
1451 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
1452 {
1453         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
1454         ndr->depth++;
1455         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
1456         ndr_print_ptr(ndr, "description", r->description);
1457         ndr->depth++;
1458         if (r->description) {
1459                 ndr_print_string(ndr, "description", r->description);
1460         }
1461         ndr->depth--;
1462         ndr_print_ptr(ndr, "name", r->name);
1463         ndr->depth++;
1464         if (r->name) {
1465                 ndr_print_string(ndr, "name", r->name);
1466         }
1467         ndr->depth--;
1468         ndr_print_ptr(ndr, "comment", r->comment);
1469         ndr->depth++;
1470         if (r->comment) {
1471                 ndr_print_string(ndr, "comment", r->comment);
1472         }
1473         ndr->depth--;
1474         ndr->depth--;
1475 }
1476
1477 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo1(const struct spoolss_PrinterInfo1 *r, struct smb_iconv_convenience *ic, int flags)
1478 {
1479         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1, ic);
1480 }
1481
1482 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
1483 {
1484         if (ndr_flags & NDR_SCALARS) {
1485                 NDR_CHECK(ndr_push_align(ndr, 5));
1486                 {
1487                         uint32_t _flags_save_string = ndr->flags;
1488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1489                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1490                         ndr->flags = _flags_save_string;
1491                 }
1492                 {
1493                         uint32_t _flags_save_string = ndr->flags;
1494                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1495                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1496                         ndr->flags = _flags_save_string;
1497                 }
1498                 {
1499                         uint32_t _flags_save_string = ndr->flags;
1500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1501                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
1502                         ndr->flags = _flags_save_string;
1503                 }
1504                 {
1505                         uint32_t _flags_save_string = ndr->flags;
1506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1507                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1508                         ndr->flags = _flags_save_string;
1509                 }
1510                 {
1511                         uint32_t _flags_save_string = ndr->flags;
1512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1513                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1514                         ndr->flags = _flags_save_string;
1515                 }
1516                 {
1517                         uint32_t _flags_save_string = ndr->flags;
1518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1519                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1520                         ndr->flags = _flags_save_string;
1521                 }
1522                 {
1523                         uint32_t _flags_save_string = ndr->flags;
1524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1525                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1526                         ndr->flags = _flags_save_string;
1527                 }
1528                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1529                 {
1530                         uint32_t _flags_save_string = ndr->flags;
1531                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1532                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1533                         ndr->flags = _flags_save_string;
1534                 }
1535                 {
1536                         uint32_t _flags_save_string = ndr->flags;
1537                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1538                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1539                         ndr->flags = _flags_save_string;
1540                 }
1541                 {
1542                         uint32_t _flags_save_string = ndr->flags;
1543                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1544                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1545                         ndr->flags = _flags_save_string;
1546                 }
1547                 {
1548                         uint32_t _flags_save_string = ndr->flags;
1549                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1550                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1551                         ndr->flags = _flags_save_string;
1552                 }
1553                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1554                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1555                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1559                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1560                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1561                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1562                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1563         }
1564         if (ndr_flags & NDR_BUFFERS) {
1565                 {
1566                         uint32_t _flags_save_string = ndr->flags;
1567                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1568                         if (r->servername) {
1569                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1570                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1571                         }
1572                         ndr->flags = _flags_save_string;
1573                 }
1574                 {
1575                         uint32_t _flags_save_string = ndr->flags;
1576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1577                         if (r->printername) {
1578                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1579                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1580                         }
1581                         ndr->flags = _flags_save_string;
1582                 }
1583                 {
1584                         uint32_t _flags_save_string = ndr->flags;
1585                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1586                         if (r->sharename) {
1587                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1588                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1589                         }
1590                         ndr->flags = _flags_save_string;
1591                 }
1592                 {
1593                         uint32_t _flags_save_string = ndr->flags;
1594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1595                         if (r->portname) {
1596                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1597                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1598                         }
1599                         ndr->flags = _flags_save_string;
1600                 }
1601                 {
1602                         uint32_t _flags_save_string = ndr->flags;
1603                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1604                         if (r->drivername) {
1605                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1606                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
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->comment) {
1614                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1615                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1616                         }
1617                         ndr->flags = _flags_save_string;
1618                 }
1619                 {
1620                         uint32_t _flags_save_string = ndr->flags;
1621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1622                         if (r->location) {
1623                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1624                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1625                         }
1626                         ndr->flags = _flags_save_string;
1627                 }
1628                 if (r->devmode) {
1629                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1630                         {
1631                                 struct ndr_push *_ndr_devmode;
1632                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1633                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1634                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1635                         }
1636                 }
1637                 {
1638                         uint32_t _flags_save_string = ndr->flags;
1639                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1640                         if (r->sepfile) {
1641                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1642                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1643                         }
1644                         ndr->flags = _flags_save_string;
1645                 }
1646                 {
1647                         uint32_t _flags_save_string = ndr->flags;
1648                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1649                         if (r->printprocessor) {
1650                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1651                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1652                         }
1653                         ndr->flags = _flags_save_string;
1654                 }
1655                 {
1656                         uint32_t _flags_save_string = ndr->flags;
1657                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1658                         if (r->datatype) {
1659                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1660                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1661                         }
1662                         ndr->flags = _flags_save_string;
1663                 }
1664                 {
1665                         uint32_t _flags_save_string = ndr->flags;
1666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1667                         if (r->parameters) {
1668                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1669                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1670                         }
1671                         ndr->flags = _flags_save_string;
1672                 }
1673                 if (r->secdesc) {
1674                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1675                         {
1676                                 struct ndr_push *_ndr_secdesc;
1677                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1678                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1679                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1680                         }
1681                 }
1682         }
1683         return NDR_ERR_SUCCESS;
1684 }
1685
1686 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1687 {
1688         uint32_t _ptr_servername;
1689         TALLOC_CTX *_mem_save_servername_0;
1690         uint32_t _ptr_printername;
1691         TALLOC_CTX *_mem_save_printername_0;
1692         uint32_t _ptr_sharename;
1693         TALLOC_CTX *_mem_save_sharename_0;
1694         uint32_t _ptr_portname;
1695         TALLOC_CTX *_mem_save_portname_0;
1696         uint32_t _ptr_drivername;
1697         TALLOC_CTX *_mem_save_drivername_0;
1698         uint32_t _ptr_comment;
1699         TALLOC_CTX *_mem_save_comment_0;
1700         uint32_t _ptr_location;
1701         TALLOC_CTX *_mem_save_location_0;
1702         uint32_t _ptr_devmode;
1703         TALLOC_CTX *_mem_save_devmode_0;
1704         uint32_t _ptr_sepfile;
1705         TALLOC_CTX *_mem_save_sepfile_0;
1706         uint32_t _ptr_printprocessor;
1707         TALLOC_CTX *_mem_save_printprocessor_0;
1708         uint32_t _ptr_datatype;
1709         TALLOC_CTX *_mem_save_datatype_0;
1710         uint32_t _ptr_parameters;
1711         TALLOC_CTX *_mem_save_parameters_0;
1712         uint32_t _ptr_secdesc;
1713         TALLOC_CTX *_mem_save_secdesc_0;
1714         if (ndr_flags & NDR_SCALARS) {
1715                 NDR_CHECK(ndr_pull_align(ndr, 5));
1716                 {
1717                         uint32_t _flags_save_string = ndr->flags;
1718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1719                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1720                         if (_ptr_servername) {
1721                                 NDR_PULL_ALLOC(ndr, r->servername);
1722                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1723                         } else {
1724                                 r->servername = NULL;
1725                         }
1726                         ndr->flags = _flags_save_string;
1727                 }
1728                 {
1729                         uint32_t _flags_save_string = ndr->flags;
1730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1731                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1732                         if (_ptr_printername) {
1733                                 NDR_PULL_ALLOC(ndr, r->printername);
1734                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1735                         } else {
1736                                 r->printername = NULL;
1737                         }
1738                         ndr->flags = _flags_save_string;
1739                 }
1740                 {
1741                         uint32_t _flags_save_string = ndr->flags;
1742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1743                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1744                         if (_ptr_sharename) {
1745                                 NDR_PULL_ALLOC(ndr, r->sharename);
1746                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1747                         } else {
1748                                 r->sharename = NULL;
1749                         }
1750                         ndr->flags = _flags_save_string;
1751                 }
1752                 {
1753                         uint32_t _flags_save_string = ndr->flags;
1754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1755                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1756                         if (_ptr_portname) {
1757                                 NDR_PULL_ALLOC(ndr, r->portname);
1758                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1759                         } else {
1760                                 r->portname = NULL;
1761                         }
1762                         ndr->flags = _flags_save_string;
1763                 }
1764                 {
1765                         uint32_t _flags_save_string = ndr->flags;
1766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1767                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1768                         if (_ptr_drivername) {
1769                                 NDR_PULL_ALLOC(ndr, r->drivername);
1770                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1771                         } else {
1772                                 r->drivername = NULL;
1773                         }
1774                         ndr->flags = _flags_save_string;
1775                 }
1776                 {
1777                         uint32_t _flags_save_string = ndr->flags;
1778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1779                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1780                         if (_ptr_comment) {
1781                                 NDR_PULL_ALLOC(ndr, r->comment);
1782                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1783                         } else {
1784                                 r->comment = NULL;
1785                         }
1786                         ndr->flags = _flags_save_string;
1787                 }
1788                 {
1789                         uint32_t _flags_save_string = ndr->flags;
1790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1791                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1792                         if (_ptr_location) {
1793                                 NDR_PULL_ALLOC(ndr, r->location);
1794                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1795                         } else {
1796                                 r->location = NULL;
1797                         }
1798                         ndr->flags = _flags_save_string;
1799                 }
1800                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1801                 if (_ptr_devmode) {
1802                         NDR_PULL_ALLOC(ndr, r->devmode);
1803                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1804                 } else {
1805                         r->devmode = NULL;
1806                 }
1807                 {
1808                         uint32_t _flags_save_string = ndr->flags;
1809                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1810                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1811                         if (_ptr_sepfile) {
1812                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1813                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1814                         } else {
1815                                 r->sepfile = NULL;
1816                         }
1817                         ndr->flags = _flags_save_string;
1818                 }
1819                 {
1820                         uint32_t _flags_save_string = ndr->flags;
1821                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1822                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1823                         if (_ptr_printprocessor) {
1824                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1825                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1826                         } else {
1827                                 r->printprocessor = NULL;
1828                         }
1829                         ndr->flags = _flags_save_string;
1830                 }
1831                 {
1832                         uint32_t _flags_save_string = ndr->flags;
1833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1834                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1835                         if (_ptr_datatype) {
1836                                 NDR_PULL_ALLOC(ndr, r->datatype);
1837                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1838                         } else {
1839                                 r->datatype = NULL;
1840                         }
1841                         ndr->flags = _flags_save_string;
1842                 }
1843                 {
1844                         uint32_t _flags_save_string = ndr->flags;
1845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1846                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1847                         if (_ptr_parameters) {
1848                                 NDR_PULL_ALLOC(ndr, r->parameters);
1849                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1850                         } else {
1851                                 r->parameters = NULL;
1852                         }
1853                         ndr->flags = _flags_save_string;
1854                 }
1855                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1856                 if (_ptr_secdesc) {
1857                         NDR_PULL_ALLOC(ndr, r->secdesc);
1858                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1859                 } else {
1860                         r->secdesc = NULL;
1861                 }
1862                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1864                 if (r->priority > 99) {
1865                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1866                 }
1867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1868                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1869                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1870                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1873                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1874         }
1875         if (ndr_flags & NDR_BUFFERS) {
1876                 {
1877                         uint32_t _flags_save_string = ndr->flags;
1878                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1879                         if (r->servername) {
1880                                 uint32_t _relative_save_offset;
1881                                 _relative_save_offset = ndr->offset;
1882                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1883                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1884                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1885                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1886                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1887                                 if (ndr->offset > ndr->relative_highest_offset) {
1888                                         ndr->relative_highest_offset = ndr->offset;
1889                                 }
1890                                 ndr->offset = _relative_save_offset;
1891                         }
1892                         ndr->flags = _flags_save_string;
1893                 }
1894                 {
1895                         uint32_t _flags_save_string = ndr->flags;
1896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1897                         if (r->printername) {
1898                                 uint32_t _relative_save_offset;
1899                                 _relative_save_offset = ndr->offset;
1900                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1901                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1902                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1903                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1904                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1905                                 if (ndr->offset > ndr->relative_highest_offset) {
1906                                         ndr->relative_highest_offset = ndr->offset;
1907                                 }
1908                                 ndr->offset = _relative_save_offset;
1909                         }
1910                         ndr->flags = _flags_save_string;
1911                 }
1912                 {
1913                         uint32_t _flags_save_string = ndr->flags;
1914                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1915                         if (r->sharename) {
1916                                 uint32_t _relative_save_offset;
1917                                 _relative_save_offset = ndr->offset;
1918                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1919                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1920                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1921                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1922                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1923                                 if (ndr->offset > ndr->relative_highest_offset) {
1924                                         ndr->relative_highest_offset = ndr->offset;
1925                                 }
1926                                 ndr->offset = _relative_save_offset;
1927                         }
1928                         ndr->flags = _flags_save_string;
1929                 }
1930                 {
1931                         uint32_t _flags_save_string = ndr->flags;
1932                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1933                         if (r->portname) {
1934                                 uint32_t _relative_save_offset;
1935                                 _relative_save_offset = ndr->offset;
1936                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1937                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1938                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1939                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1940                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1941                                 if (ndr->offset > ndr->relative_highest_offset) {
1942                                         ndr->relative_highest_offset = ndr->offset;
1943                                 }
1944                                 ndr->offset = _relative_save_offset;
1945                         }
1946                         ndr->flags = _flags_save_string;
1947                 }
1948                 {
1949                         uint32_t _flags_save_string = ndr->flags;
1950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1951                         if (r->drivername) {
1952                                 uint32_t _relative_save_offset;
1953                                 _relative_save_offset = ndr->offset;
1954                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1955                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1956                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1957                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1958                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1959                                 if (ndr->offset > ndr->relative_highest_offset) {
1960                                         ndr->relative_highest_offset = ndr->offset;
1961                                 }
1962                                 ndr->offset = _relative_save_offset;
1963                         }
1964                         ndr->flags = _flags_save_string;
1965                 }
1966                 {
1967                         uint32_t _flags_save_string = ndr->flags;
1968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1969                         if (r->comment) {
1970                                 uint32_t _relative_save_offset;
1971                                 _relative_save_offset = ndr->offset;
1972                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1973                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1974                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1975                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1976                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1977                                 if (ndr->offset > ndr->relative_highest_offset) {
1978                                         ndr->relative_highest_offset = ndr->offset;
1979                                 }
1980                                 ndr->offset = _relative_save_offset;
1981                         }
1982                         ndr->flags = _flags_save_string;
1983                 }
1984                 {
1985                         uint32_t _flags_save_string = ndr->flags;
1986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1987                         if (r->location) {
1988                                 uint32_t _relative_save_offset;
1989                                 _relative_save_offset = ndr->offset;
1990                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1991                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1992                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1993                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1994                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1995                                 if (ndr->offset > ndr->relative_highest_offset) {
1996                                         ndr->relative_highest_offset = ndr->offset;
1997                                 }
1998                                 ndr->offset = _relative_save_offset;
1999                         }
2000                         ndr->flags = _flags_save_string;
2001                 }
2002                 if (r->devmode) {
2003                         uint32_t _relative_save_offset;
2004                         _relative_save_offset = ndr->offset;
2005                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2006                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2007                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2008                         {
2009                                 struct ndr_pull *_ndr_devmode;
2010                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2011                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2012                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2013                         }
2014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2015                         if (ndr->offset > ndr->relative_highest_offset) {
2016                                 ndr->relative_highest_offset = ndr->offset;
2017                         }
2018                         ndr->offset = _relative_save_offset;
2019                 }
2020                 {
2021                         uint32_t _flags_save_string = ndr->flags;
2022                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2023                         if (r->sepfile) {
2024                                 uint32_t _relative_save_offset;
2025                                 _relative_save_offset = ndr->offset;
2026                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
2027                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
2028                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
2029                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
2030                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
2031                                 if (ndr->offset > ndr->relative_highest_offset) {
2032                                         ndr->relative_highest_offset = ndr->offset;
2033                                 }
2034                                 ndr->offset = _relative_save_offset;
2035                         }
2036                         ndr->flags = _flags_save_string;
2037                 }
2038                 {
2039                         uint32_t _flags_save_string = ndr->flags;
2040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2041                         if (r->printprocessor) {
2042                                 uint32_t _relative_save_offset;
2043                                 _relative_save_offset = ndr->offset;
2044                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
2045                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
2046                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
2047                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
2048                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
2049                                 if (ndr->offset > ndr->relative_highest_offset) {
2050                                         ndr->relative_highest_offset = ndr->offset;
2051                                 }
2052                                 ndr->offset = _relative_save_offset;
2053                         }
2054                         ndr->flags = _flags_save_string;
2055                 }
2056                 {
2057                         uint32_t _flags_save_string = ndr->flags;
2058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2059                         if (r->datatype) {
2060                                 uint32_t _relative_save_offset;
2061                                 _relative_save_offset = ndr->offset;
2062                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
2063                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
2064                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
2065                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
2066                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
2067                                 if (ndr->offset > ndr->relative_highest_offset) {
2068                                         ndr->relative_highest_offset = ndr->offset;
2069                                 }
2070                                 ndr->offset = _relative_save_offset;
2071                         }
2072                         ndr->flags = _flags_save_string;
2073                 }
2074                 {
2075                         uint32_t _flags_save_string = ndr->flags;
2076                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2077                         if (r->parameters) {
2078                                 uint32_t _relative_save_offset;
2079                                 _relative_save_offset = ndr->offset;
2080                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
2081                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
2082                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
2083                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
2084                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
2085                                 if (ndr->offset > ndr->relative_highest_offset) {
2086                                         ndr->relative_highest_offset = ndr->offset;
2087                                 }
2088                                 ndr->offset = _relative_save_offset;
2089                         }
2090                         ndr->flags = _flags_save_string;
2091                 }
2092                 if (r->secdesc) {
2093                         uint32_t _relative_save_offset;
2094                         _relative_save_offset = ndr->offset;
2095                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2096                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2097                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2098                         {
2099                                 struct ndr_pull *_ndr_secdesc;
2100                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2101                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2102                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2103                         }
2104                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2105                         if (ndr->offset > ndr->relative_highest_offset) {
2106                                 ndr->relative_highest_offset = ndr->offset;
2107                         }
2108                         ndr->offset = _relative_save_offset;
2109                 }
2110         }
2111         return NDR_ERR_SUCCESS;
2112 }
2113
2114 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
2115 {
2116         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
2117         ndr->depth++;
2118         ndr_print_ptr(ndr, "servername", r->servername);
2119         ndr->depth++;
2120         if (r->servername) {
2121                 ndr_print_string(ndr, "servername", r->servername);
2122         }
2123         ndr->depth--;
2124         ndr_print_ptr(ndr, "printername", r->printername);
2125         ndr->depth++;
2126         if (r->printername) {
2127                 ndr_print_string(ndr, "printername", r->printername);
2128         }
2129         ndr->depth--;
2130         ndr_print_ptr(ndr, "sharename", r->sharename);
2131         ndr->depth++;
2132         if (r->sharename) {
2133                 ndr_print_string(ndr, "sharename", r->sharename);
2134         }
2135         ndr->depth--;
2136         ndr_print_ptr(ndr, "portname", r->portname);
2137         ndr->depth++;
2138         if (r->portname) {
2139                 ndr_print_string(ndr, "portname", r->portname);
2140         }
2141         ndr->depth--;
2142         ndr_print_ptr(ndr, "drivername", r->drivername);
2143         ndr->depth++;
2144         if (r->drivername) {
2145                 ndr_print_string(ndr, "drivername", r->drivername);
2146         }
2147         ndr->depth--;
2148         ndr_print_ptr(ndr, "comment", r->comment);
2149         ndr->depth++;
2150         if (r->comment) {
2151                 ndr_print_string(ndr, "comment", r->comment);
2152         }
2153         ndr->depth--;
2154         ndr_print_ptr(ndr, "location", r->location);
2155         ndr->depth++;
2156         if (r->location) {
2157                 ndr_print_string(ndr, "location", r->location);
2158         }
2159         ndr->depth--;
2160         ndr_print_ptr(ndr, "devmode", r->devmode);
2161         ndr->depth++;
2162         if (r->devmode) {
2163                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2164         }
2165         ndr->depth--;
2166         ndr_print_ptr(ndr, "sepfile", r->sepfile);
2167         ndr->depth++;
2168         if (r->sepfile) {
2169                 ndr_print_string(ndr, "sepfile", r->sepfile);
2170         }
2171         ndr->depth--;
2172         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
2173         ndr->depth++;
2174         if (r->printprocessor) {
2175                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
2176         }
2177         ndr->depth--;
2178         ndr_print_ptr(ndr, "datatype", r->datatype);
2179         ndr->depth++;
2180         if (r->datatype) {
2181                 ndr_print_string(ndr, "datatype", r->datatype);
2182         }
2183         ndr->depth--;
2184         ndr_print_ptr(ndr, "parameters", r->parameters);
2185         ndr->depth++;
2186         if (r->parameters) {
2187                 ndr_print_string(ndr, "parameters", r->parameters);
2188         }
2189         ndr->depth--;
2190         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2191         ndr->depth++;
2192         if (r->secdesc) {
2193                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
2194         }
2195         ndr->depth--;
2196         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2197         ndr_print_uint32(ndr, "priority", r->priority);
2198         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
2199         ndr_print_uint32(ndr, "starttime", r->starttime);
2200         ndr_print_uint32(ndr, "untiltime", r->untiltime);
2201         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2202         ndr_print_uint32(ndr, "cjobs", r->cjobs);
2203         ndr_print_uint32(ndr, "averageppm", r->averageppm);
2204         ndr->depth--;
2205 }
2206
2207 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo2(const struct spoolss_PrinterInfo2 *r, struct smb_iconv_convenience *ic, int flags)
2208 {
2209         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2, ic);
2210 }
2211
2212 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
2213 {
2214         if (ndr_flags & NDR_SCALARS) {
2215                 NDR_CHECK(ndr_push_align(ndr, 5));
2216                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
2217                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2218         }
2219         if (ndr_flags & NDR_BUFFERS) {
2220                 if (r->secdesc) {
2221                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
2222                         {
2223                                 struct ndr_push *_ndr_secdesc;
2224                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2225                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2226                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2227                         }
2228                 }
2229         }
2230         return NDR_ERR_SUCCESS;
2231 }
2232
2233 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
2234 {
2235         uint32_t _ptr_secdesc;
2236         TALLOC_CTX *_mem_save_secdesc_0;
2237         if (ndr_flags & NDR_SCALARS) {
2238                 NDR_CHECK(ndr_pull_align(ndr, 5));
2239                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
2240                 if (_ptr_secdesc) {
2241                         NDR_PULL_ALLOC(ndr, r->secdesc);
2242                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
2243                 } else {
2244                         r->secdesc = NULL;
2245                 }
2246                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2247         }
2248         if (ndr_flags & NDR_BUFFERS) {
2249                 if (r->secdesc) {
2250                         uint32_t _relative_save_offset;
2251                         _relative_save_offset = ndr->offset;
2252                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2253                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2254                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2255                         {
2256                                 struct ndr_pull *_ndr_secdesc;
2257                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2258                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2259                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2260                         }
2261                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2262                         if (ndr->offset > ndr->relative_highest_offset) {
2263                                 ndr->relative_highest_offset = ndr->offset;
2264                         }
2265                         ndr->offset = _relative_save_offset;
2266                 }
2267         }
2268         return NDR_ERR_SUCCESS;
2269 }
2270
2271 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
2272 {
2273         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
2274         ndr->depth++;
2275         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2276         ndr->depth++;
2277         if (r->secdesc) {
2278                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
2279         }
2280         ndr->depth--;
2281         ndr->depth--;
2282 }
2283
2284 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo3(const struct spoolss_PrinterInfo3 *r, struct smb_iconv_convenience *ic, int flags)
2285 {
2286         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo3, ic);
2287 }
2288
2289 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
2290 {
2291         if (ndr_flags & NDR_SCALARS) {
2292                 NDR_CHECK(ndr_push_align(ndr, 5));
2293                 {
2294                         uint32_t _flags_save_string = ndr->flags;
2295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2296                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2297                         ndr->flags = _flags_save_string;
2298                 }
2299                 {
2300                         uint32_t _flags_save_string = ndr->flags;
2301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2302                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
2303                         ndr->flags = _flags_save_string;
2304                 }
2305                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2306                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2307         }
2308         if (ndr_flags & NDR_BUFFERS) {
2309                 {
2310                         uint32_t _flags_save_string = ndr->flags;
2311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2312                         if (r->printername) {
2313                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
2314                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2315                         }
2316                         ndr->flags = _flags_save_string;
2317                 }
2318                 {
2319                         uint32_t _flags_save_string = ndr->flags;
2320                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2321                         if (r->servername) {
2322                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
2323                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
2324                         }
2325                         ndr->flags = _flags_save_string;
2326                 }
2327         }
2328         return NDR_ERR_SUCCESS;
2329 }
2330
2331 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
2332 {
2333         uint32_t _ptr_printername;
2334         TALLOC_CTX *_mem_save_printername_0;
2335         uint32_t _ptr_servername;
2336         TALLOC_CTX *_mem_save_servername_0;
2337         if (ndr_flags & NDR_SCALARS) {
2338                 NDR_CHECK(ndr_pull_align(ndr, 5));
2339                 {
2340                         uint32_t _flags_save_string = ndr->flags;
2341                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2342                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2343                         if (_ptr_printername) {
2344                                 NDR_PULL_ALLOC(ndr, r->printername);
2345                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2346                         } else {
2347                                 r->printername = NULL;
2348                         }
2349                         ndr->flags = _flags_save_string;
2350                 }
2351                 {
2352                         uint32_t _flags_save_string = ndr->flags;
2353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2354                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
2355                         if (_ptr_servername) {
2356                                 NDR_PULL_ALLOC(ndr, r->servername);
2357                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
2358                         } else {
2359                                 r->servername = NULL;
2360                         }
2361                         ndr->flags = _flags_save_string;
2362                 }
2363                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2364                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2365         }
2366         if (ndr_flags & NDR_BUFFERS) {
2367                 {
2368                         uint32_t _flags_save_string = ndr->flags;
2369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2370                         if (r->printername) {
2371                                 uint32_t _relative_save_offset;
2372                                 _relative_save_offset = ndr->offset;
2373                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2374                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2375                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2376                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2377                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2378                                 if (ndr->offset > ndr->relative_highest_offset) {
2379                                         ndr->relative_highest_offset = ndr->offset;
2380                                 }
2381                                 ndr->offset = _relative_save_offset;
2382                         }
2383                         ndr->flags = _flags_save_string;
2384                 }
2385                 {
2386                         uint32_t _flags_save_string = ndr->flags;
2387                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2388                         if (r->servername) {
2389                                 uint32_t _relative_save_offset;
2390                                 _relative_save_offset = ndr->offset;
2391                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
2392                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2393                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
2394                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
2395                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
2396                                 if (ndr->offset > ndr->relative_highest_offset) {
2397                                         ndr->relative_highest_offset = ndr->offset;
2398                                 }
2399                                 ndr->offset = _relative_save_offset;
2400                         }
2401                         ndr->flags = _flags_save_string;
2402                 }
2403         }
2404         return NDR_ERR_SUCCESS;
2405 }
2406
2407 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
2408 {
2409         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
2410         ndr->depth++;
2411         ndr_print_ptr(ndr, "printername", r->printername);
2412         ndr->depth++;
2413         if (r->printername) {
2414                 ndr_print_string(ndr, "printername", r->printername);
2415         }
2416         ndr->depth--;
2417         ndr_print_ptr(ndr, "servername", r->servername);
2418         ndr->depth++;
2419         if (r->servername) {
2420                 ndr_print_string(ndr, "servername", r->servername);
2421         }
2422         ndr->depth--;
2423         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2424         ndr->depth--;
2425 }
2426
2427 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo4(const struct spoolss_PrinterInfo4 *r, struct smb_iconv_convenience *ic, int flags)
2428 {
2429         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo4, ic);
2430 }
2431
2432 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
2433 {
2434         if (ndr_flags & NDR_SCALARS) {
2435                 NDR_CHECK(ndr_push_align(ndr, 5));
2436                 {
2437                         uint32_t _flags_save_string = ndr->flags;
2438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2439                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2440                         ndr->flags = _flags_save_string;
2441                 }
2442                 {
2443                         uint32_t _flags_save_string = ndr->flags;
2444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2445                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
2446                         ndr->flags = _flags_save_string;
2447                 }
2448                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
2450                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
2451                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2452         }
2453         if (ndr_flags & NDR_BUFFERS) {
2454                 {
2455                         uint32_t _flags_save_string = ndr->flags;
2456                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2457                         if (r->printername) {
2458                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
2459                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2460                         }
2461                         ndr->flags = _flags_save_string;
2462                 }
2463                 {
2464                         uint32_t _flags_save_string = ndr->flags;
2465                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2466                         if (r->portname) {
2467                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
2468                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
2469                         }
2470                         ndr->flags = _flags_save_string;
2471                 }
2472         }
2473         return NDR_ERR_SUCCESS;
2474 }
2475
2476 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
2477 {
2478         uint32_t _ptr_printername;
2479         TALLOC_CTX *_mem_save_printername_0;
2480         uint32_t _ptr_portname;
2481         TALLOC_CTX *_mem_save_portname_0;
2482         if (ndr_flags & NDR_SCALARS) {
2483                 NDR_CHECK(ndr_pull_align(ndr, 5));
2484                 {
2485                         uint32_t _flags_save_string = ndr->flags;
2486                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2487                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2488                         if (_ptr_printername) {
2489                                 NDR_PULL_ALLOC(ndr, r->printername);
2490                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2491                         } else {
2492                                 r->printername = NULL;
2493                         }
2494                         ndr->flags = _flags_save_string;
2495                 }
2496                 {
2497                         uint32_t _flags_save_string = ndr->flags;
2498                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2499                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
2500                         if (_ptr_portname) {
2501                                 NDR_PULL_ALLOC(ndr, r->portname);
2502                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
2503                         } else {
2504                                 r->portname = NULL;
2505                         }
2506                         ndr->flags = _flags_save_string;
2507                 }
2508                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2509                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
2510                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
2511                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2512         }
2513         if (ndr_flags & NDR_BUFFERS) {
2514                 {
2515                         uint32_t _flags_save_string = ndr->flags;
2516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2517                         if (r->printername) {
2518                                 uint32_t _relative_save_offset;
2519                                 _relative_save_offset = ndr->offset;
2520                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2521                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2522                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2523                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2524                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2525                                 if (ndr->offset > ndr->relative_highest_offset) {
2526                                         ndr->relative_highest_offset = ndr->offset;
2527                                 }
2528                                 ndr->offset = _relative_save_offset;
2529                         }
2530                         ndr->flags = _flags_save_string;
2531                 }
2532                 {
2533                         uint32_t _flags_save_string = ndr->flags;
2534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2535                         if (r->portname) {
2536                                 uint32_t _relative_save_offset;
2537                                 _relative_save_offset = ndr->offset;
2538                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
2539                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2540                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
2541                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
2542                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
2543                                 if (ndr->offset > ndr->relative_highest_offset) {
2544                                         ndr->relative_highest_offset = ndr->offset;
2545                                 }
2546                                 ndr->offset = _relative_save_offset;
2547                         }
2548                         ndr->flags = _flags_save_string;
2549                 }
2550         }
2551         return NDR_ERR_SUCCESS;
2552 }
2553
2554 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
2555 {
2556         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
2557         ndr->depth++;
2558         ndr_print_ptr(ndr, "printername", r->printername);
2559         ndr->depth++;
2560         if (r->printername) {
2561                 ndr_print_string(ndr, "printername", r->printername);
2562         }
2563         ndr->depth--;
2564         ndr_print_ptr(ndr, "portname", r->portname);
2565         ndr->depth++;
2566         if (r->portname) {
2567                 ndr_print_string(ndr, "portname", r->portname);
2568         }
2569         ndr->depth--;
2570         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2571         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
2572         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
2573         ndr->depth--;
2574 }
2575
2576 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo5(const struct spoolss_PrinterInfo5 *r, struct smb_iconv_convenience *ic, int flags)
2577 {
2578         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5, ic);
2579 }
2580
2581 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
2582 {
2583         if (ndr_flags & NDR_SCALARS) {
2584                 NDR_CHECK(ndr_push_align(ndr, 4));
2585                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
2586                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2587         }
2588         if (ndr_flags & NDR_BUFFERS) {
2589         }
2590         return NDR_ERR_SUCCESS;
2591 }
2592
2593 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2594 {
2595         if (ndr_flags & NDR_SCALARS) {
2596                 NDR_CHECK(ndr_pull_align(ndr, 4));
2597                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2598                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2599         }
2600         if (ndr_flags & NDR_BUFFERS) {
2601         }
2602         return NDR_ERR_SUCCESS;
2603 }
2604
2605 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2606 {
2607         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2608         ndr->depth++;
2609         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2610         ndr->depth--;
2611 }
2612
2613 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo6(const struct spoolss_PrinterInfo6 *r, struct smb_iconv_convenience *ic, int flags)
2614 {
2615         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo6, ic);
2616 }
2617
2618 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2619 {
2620         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2621         return NDR_ERR_SUCCESS;
2622 }
2623
2624 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2625 {
2626         uint32_t v;
2627         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2628         *r = v;
2629         return NDR_ERR_SUCCESS;
2630 }
2631
2632 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2633 {
2634         ndr_print_uint32(ndr, name, r);
2635         ndr->depth++;
2636         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2637         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2638         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2639         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2640         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2641         ndr->depth--;
2642 }
2643
2644 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2645 {
2646         if (ndr_flags & NDR_SCALARS) {
2647                 NDR_CHECK(ndr_push_align(ndr, 5));
2648                 {
2649                         uint32_t _flags_save_string = ndr->flags;
2650                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2651                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2652                         ndr->flags = _flags_save_string;
2653                 }
2654                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2655                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2656         }
2657         if (ndr_flags & NDR_BUFFERS) {
2658                 {
2659                         uint32_t _flags_save_string = ndr->flags;
2660                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2661                         if (r->guid) {
2662                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2663                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2664                         }
2665                         ndr->flags = _flags_save_string;
2666                 }
2667         }
2668         return NDR_ERR_SUCCESS;
2669 }
2670
2671 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2672 {
2673         uint32_t _ptr_guid;
2674         TALLOC_CTX *_mem_save_guid_0;
2675         if (ndr_flags & NDR_SCALARS) {
2676                 NDR_CHECK(ndr_pull_align(ndr, 5));
2677                 {
2678                         uint32_t _flags_save_string = ndr->flags;
2679                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2680                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2681                         if (_ptr_guid) {
2682                                 NDR_PULL_ALLOC(ndr, r->guid);
2683                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2684                         } else {
2685                                 r->guid = NULL;
2686                         }
2687                         ndr->flags = _flags_save_string;
2688                 }
2689                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2690                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2691         }
2692         if (ndr_flags & NDR_BUFFERS) {
2693                 {
2694                         uint32_t _flags_save_string = ndr->flags;
2695                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2696                         if (r->guid) {
2697                                 uint32_t _relative_save_offset;
2698                                 _relative_save_offset = ndr->offset;
2699                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2700                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2701                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2702                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2703                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2704                                 if (ndr->offset > ndr->relative_highest_offset) {
2705                                         ndr->relative_highest_offset = ndr->offset;
2706                                 }
2707                                 ndr->offset = _relative_save_offset;
2708                         }
2709                         ndr->flags = _flags_save_string;
2710                 }
2711         }
2712         return NDR_ERR_SUCCESS;
2713 }
2714
2715 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2716 {
2717         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2718         ndr->depth++;
2719         ndr_print_ptr(ndr, "guid", r->guid);
2720         ndr->depth++;
2721         if (r->guid) {
2722                 ndr_print_string(ndr, "guid", r->guid);
2723         }
2724         ndr->depth--;
2725         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2726         ndr->depth--;
2727 }
2728
2729 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo7(const struct spoolss_PrinterInfo7 *r, struct smb_iconv_convenience *ic, int flags)
2730 {
2731         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo7, ic);
2732 }
2733
2734 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2735 {
2736         if (ndr_flags & NDR_SCALARS) {
2737                 NDR_CHECK(ndr_push_align(ndr, 5));
2738                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2739                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2740         }
2741         if (ndr_flags & NDR_BUFFERS) {
2742                 if (r->devmode) {
2743                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2744                         {
2745                                 struct ndr_push *_ndr_devmode;
2746                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2747                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2748                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2749                         }
2750                 }
2751         }
2752         return NDR_ERR_SUCCESS;
2753 }
2754
2755 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2756 {
2757         uint32_t _ptr_devmode;
2758         TALLOC_CTX *_mem_save_devmode_0;
2759         if (ndr_flags & NDR_SCALARS) {
2760                 NDR_CHECK(ndr_pull_align(ndr, 5));
2761                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2762                 if (_ptr_devmode) {
2763                         NDR_PULL_ALLOC(ndr, r->devmode);
2764                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2765                 } else {
2766                         r->devmode = NULL;
2767                 }
2768                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2769         }
2770         if (ndr_flags & NDR_BUFFERS) {
2771                 if (r->devmode) {
2772                         uint32_t _relative_save_offset;
2773                         _relative_save_offset = ndr->offset;
2774                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2775                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2776                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2777                         {
2778                                 struct ndr_pull *_ndr_devmode;
2779                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2780                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2781                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2782                         }
2783                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2784                         if (ndr->offset > ndr->relative_highest_offset) {
2785                                 ndr->relative_highest_offset = ndr->offset;
2786                         }
2787                         ndr->offset = _relative_save_offset;
2788                 }
2789         }
2790         return NDR_ERR_SUCCESS;
2791 }
2792
2793 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2794 {
2795         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2796         ndr->depth++;
2797         ndr_print_ptr(ndr, "devmode", r->devmode);
2798         ndr->depth++;
2799         if (r->devmode) {
2800                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2801         }
2802         ndr->depth--;
2803         ndr->depth--;
2804 }
2805
2806 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2807 {
2808         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2809         if (ndr_flags & NDR_SCALARS) {
2810                 int level = ndr_push_get_switch_value(ndr, r);
2811                 NDR_CHECK(ndr_push_union_align(ndr, 5));
2812                 switch (level) {
2813                         case 0: {
2814                                 NDR_CHECK(ndr_push_align(ndr, 5));
2815                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2816                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2817                         break; }
2818
2819                         case 1: {
2820                                 NDR_CHECK(ndr_push_align(ndr, 5));
2821                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2822                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2823                         break; }
2824
2825                         case 2: {
2826                                 NDR_CHECK(ndr_push_align(ndr, 5));
2827                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2828                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2829                         break; }
2830
2831                         case 3: {
2832                                 NDR_CHECK(ndr_push_align(ndr, 5));
2833                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2834                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2835                         break; }
2836
2837                         case 4: {
2838                                 NDR_CHECK(ndr_push_align(ndr, 5));
2839                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2840                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2841                         break; }
2842
2843                         case 5: {
2844                                 NDR_CHECK(ndr_push_align(ndr, 5));
2845                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2846                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2847                         break; }
2848
2849                         case 6: {
2850                                 NDR_CHECK(ndr_push_align(ndr, 4));
2851                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2852                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2853                         break; }
2854
2855                         case 7: {
2856                                 NDR_CHECK(ndr_push_align(ndr, 5));
2857                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2858                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2859                         break; }
2860
2861                         case 8: {
2862                                 NDR_CHECK(ndr_push_align(ndr, 5));
2863                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2864                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2865                         break; }
2866
2867                         case 9: {
2868                                 NDR_CHECK(ndr_push_align(ndr, 5));
2869                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2870                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2871                         break; }
2872
2873                         default: {
2874                         break; }
2875
2876                 }
2877         }
2878         if (ndr_flags & NDR_BUFFERS) {
2879                 int level = ndr_push_get_switch_value(ndr, r);
2880                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2881                 switch (level) {
2882                         case 0:
2883                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2884                         break;
2885
2886                         case 1:
2887                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2888                         break;
2889
2890                         case 2:
2891                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2892                         break;
2893
2894                         case 3:
2895                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2896                         break;
2897
2898                         case 4:
2899                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2900                         break;
2901
2902                         case 5:
2903                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2904                         break;
2905
2906                         case 6:
2907                         break;
2908
2909                         case 7:
2910                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2911                         break;
2912
2913                         case 8:
2914                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2915                         break;
2916
2917                         case 9:
2918                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2919                         break;
2920
2921                         default:
2922                         break;
2923
2924                 }
2925         }
2926         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2927         return NDR_ERR_SUCCESS;
2928 }
2929
2930 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2931 {
2932         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2933         int level;
2934         level = ndr_pull_get_switch_value(ndr, r);
2935         if (ndr_flags & NDR_SCALARS) {
2936                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
2937                 switch (level) {
2938                         case 0: {
2939                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2940                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2941                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2942                         break; }
2943
2944                         case 1: {
2945                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2946                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2947                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2948                         break; }
2949
2950                         case 2: {
2951                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2952                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2953                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2954                         break; }
2955
2956                         case 3: {
2957                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2958                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2959                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2960                         break; }
2961
2962                         case 4: {
2963                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2964                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2965                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2966                         break; }
2967
2968                         case 5: {
2969                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2970                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2971                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2972                         break; }
2973
2974                         case 6: {
2975                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2976                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2977                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2978                         break; }
2979
2980                         case 7: {
2981                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2982                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2983                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2984                         break; }
2985
2986                         case 8: {
2987                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2988                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2989                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2990                         break; }
2991
2992                         case 9: {
2993                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2994                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2995                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2996                         break; }
2997
2998                         default: {
2999                         break; }
3000
3001                 }
3002         }
3003         if (ndr_flags & NDR_BUFFERS) {
3004                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
3005                 switch (level) {
3006                         case 0:
3007                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
3008                         break;
3009
3010                         case 1:
3011                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
3012                         break;
3013
3014                         case 2:
3015                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
3016                         break;
3017
3018                         case 3:
3019                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
3020                         break;
3021
3022                         case 4:
3023                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
3024                         break;
3025
3026                         case 5:
3027                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
3028                         break;
3029
3030                         case 6:
3031                         break;
3032
3033                         case 7:
3034                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
3035                         break;
3036
3037                         case 8:
3038                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
3039                         break;
3040
3041                         case 9:
3042                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
3043                         break;
3044
3045                         default:
3046                         break;
3047
3048                 }
3049         }
3050         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
3051         return NDR_ERR_SUCCESS;
3052 }
3053
3054 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
3055 {
3056         int level;
3057         level = ndr_print_get_switch_value(ndr, r);
3058         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
3059         switch (level) {
3060                 case 0:
3061                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
3062                 break;
3063
3064                 case 1:
3065                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
3066                 break;
3067
3068                 case 2:
3069                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
3070                 break;
3071
3072                 case 3:
3073                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
3074                 break;
3075
3076                 case 4:
3077                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
3078                 break;
3079
3080                 case 5:
3081                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
3082                 break;
3083
3084                 case 6:
3085                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
3086                 break;
3087
3088                 case 7:
3089                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
3090                 break;
3091
3092                 case 8:
3093                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
3094                 break;
3095
3096                 case 9:
3097                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
3098                 break;
3099
3100                 default:
3101                 break;
3102
3103         }
3104 }
3105
3106 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo(const union spoolss_PrinterInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
3107 {
3108         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo, ic);
3109 }
3110
3111 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
3112 {
3113         if (ndr_flags & NDR_SCALARS) {
3114                 NDR_CHECK(ndr_push_align(ndr, 5));
3115                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3116                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
3117                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3118         }
3119         if (ndr_flags & NDR_BUFFERS) {
3120                 if (r->devmode) {
3121                         {
3122                                 struct ndr_push *_ndr_devmode;
3123                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3124                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3125                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3126                         }
3127                 }
3128         }
3129         return NDR_ERR_SUCCESS;
3130 }
3131
3132 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
3133 {
3134         uint32_t _ptr_devmode;
3135         TALLOC_CTX *_mem_save_devmode_0;
3136         if (ndr_flags & NDR_SCALARS) {
3137                 NDR_CHECK(ndr_pull_align(ndr, 5));
3138                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
3139                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3140                 if (_ptr_devmode) {
3141                         NDR_PULL_ALLOC(ndr, r->devmode);
3142                 } else {
3143                         r->devmode = NULL;
3144                 }
3145                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3146         }
3147         if (ndr_flags & NDR_BUFFERS) {
3148                 if (r->devmode) {
3149                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3150                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3151                         {
3152                                 struct ndr_pull *_ndr_devmode;
3153                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
3154                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3155                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
3156                         }
3157                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3158                 }
3159         }
3160         return NDR_ERR_SUCCESS;
3161 }
3162
3163 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
3164 {
3165         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
3166         ndr->depth++;
3167         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);
3168         ndr_print_ptr(ndr, "devmode", r->devmode);
3169         ndr->depth++;
3170         if (r->devmode) {
3171                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3172         }
3173         ndr->depth--;
3174         ndr->depth--;
3175 }
3176
3177 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
3178 {
3179         if (ndr_flags & NDR_SCALARS) {
3180                 NDR_CHECK(ndr_push_align(ndr, 5));
3181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3182                 {
3183                         uint32_t _flags_save_string = ndr->flags;
3184                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3185                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3186                         ndr->flags = _flags_save_string;
3187                 }
3188                 {
3189                         uint32_t _flags_save_string = ndr->flags;
3190                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3191                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3192                         ndr->flags = _flags_save_string;
3193                 }
3194                 {
3195                         uint32_t _flags_save_string = ndr->flags;
3196                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3197                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3198                         ndr->flags = _flags_save_string;
3199                 }
3200                 {
3201                         uint32_t _flags_save_string = ndr->flags;
3202                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3203                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3204                         ndr->flags = _flags_save_string;
3205                 }
3206                 {
3207                         uint32_t _flags_save_string = ndr->flags;
3208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3209                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3210                         ndr->flags = _flags_save_string;
3211                 }
3212                 {
3213                         uint32_t _flags_save_string = ndr->flags;
3214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3215                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3216                         ndr->flags = _flags_save_string;
3217                 }
3218                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3219                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3221                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3222                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3223                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3224                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3225         }
3226         if (ndr_flags & NDR_BUFFERS) {
3227                 {
3228                         uint32_t _flags_save_string = ndr->flags;
3229                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3230                         if (r->printer_name) {
3231                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3232                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3233                         }
3234                         ndr->flags = _flags_save_string;
3235                 }
3236                 {
3237                         uint32_t _flags_save_string = ndr->flags;
3238                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3239                         if (r->server_name) {
3240                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3241                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3242                         }
3243                         ndr->flags = _flags_save_string;
3244                 }
3245                 {
3246                         uint32_t _flags_save_string = ndr->flags;
3247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3248                         if (r->user_name) {
3249                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3250                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3251                         }
3252                         ndr->flags = _flags_save_string;
3253                 }
3254                 {
3255                         uint32_t _flags_save_string = ndr->flags;
3256                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3257                         if (r->document_name) {
3258                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3259                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3260                         }
3261                         ndr->flags = _flags_save_string;
3262                 }
3263                 {
3264                         uint32_t _flags_save_string = ndr->flags;
3265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3266                         if (r->data_type) {
3267                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3268                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3269                         }
3270                         ndr->flags = _flags_save_string;
3271                 }
3272                 {
3273                         uint32_t _flags_save_string = ndr->flags;
3274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3275                         if (r->text_status) {
3276                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3277                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3278                         }
3279                         ndr->flags = _flags_save_string;
3280                 }
3281         }
3282         return NDR_ERR_SUCCESS;
3283 }
3284
3285 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
3286 {
3287         uint32_t _ptr_printer_name;
3288         TALLOC_CTX *_mem_save_printer_name_0;
3289         uint32_t _ptr_server_name;
3290         TALLOC_CTX *_mem_save_server_name_0;
3291         uint32_t _ptr_user_name;
3292         TALLOC_CTX *_mem_save_user_name_0;
3293         uint32_t _ptr_document_name;
3294         TALLOC_CTX *_mem_save_document_name_0;
3295         uint32_t _ptr_data_type;
3296         TALLOC_CTX *_mem_save_data_type_0;
3297         uint32_t _ptr_text_status;
3298         TALLOC_CTX *_mem_save_text_status_0;
3299         if (ndr_flags & NDR_SCALARS) {
3300                 NDR_CHECK(ndr_pull_align(ndr, 5));
3301                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3302                 {
3303                         uint32_t _flags_save_string = ndr->flags;
3304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3305                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3306                         if (_ptr_printer_name) {
3307                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3308                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3309                         } else {
3310                                 r->printer_name = NULL;
3311                         }
3312                         ndr->flags = _flags_save_string;
3313                 }
3314                 {
3315                         uint32_t _flags_save_string = ndr->flags;
3316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3317                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3318                         if (_ptr_server_name) {
3319                                 NDR_PULL_ALLOC(ndr, r->server_name);
3320                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3321                         } else {
3322                                 r->server_name = NULL;
3323                         }
3324                         ndr->flags = _flags_save_string;
3325                 }
3326                 {
3327                         uint32_t _flags_save_string = ndr->flags;
3328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3329                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3330                         if (_ptr_user_name) {
3331                                 NDR_PULL_ALLOC(ndr, r->user_name);
3332                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3333                         } else {
3334                                 r->user_name = NULL;
3335                         }
3336                         ndr->flags = _flags_save_string;
3337                 }
3338                 {
3339                         uint32_t _flags_save_string = ndr->flags;
3340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3341                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3342                         if (_ptr_document_name) {
3343                                 NDR_PULL_ALLOC(ndr, r->document_name);
3344                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3345                         } else {
3346                                 r->document_name = NULL;
3347                         }
3348                         ndr->flags = _flags_save_string;
3349                 }
3350                 {
3351                         uint32_t _flags_save_string = ndr->flags;
3352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3353                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3354                         if (_ptr_data_type) {
3355                                 NDR_PULL_ALLOC(ndr, r->data_type);
3356                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3357                         } else {
3358                                 r->data_type = NULL;
3359                         }
3360                         ndr->flags = _flags_save_string;
3361                 }
3362                 {
3363                         uint32_t _flags_save_string = ndr->flags;
3364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3365                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3366                         if (_ptr_text_status) {
3367                                 NDR_PULL_ALLOC(ndr, r->text_status);
3368                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3369                         } else {
3370                                 r->text_status = NULL;
3371                         }
3372                         ndr->flags = _flags_save_string;
3373                 }
3374                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3375                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3376                 if (r->priority > 99) {
3377                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3378                 }
3379                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3382                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3383                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3384         }
3385         if (ndr_flags & NDR_BUFFERS) {
3386                 {
3387                         uint32_t _flags_save_string = ndr->flags;
3388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3389                         if (r->printer_name) {
3390                                 uint32_t _relative_save_offset;
3391                                 _relative_save_offset = ndr->offset;
3392                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3393                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3394                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3395                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3396                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3397                                 if (ndr->offset > ndr->relative_highest_offset) {
3398                                         ndr->relative_highest_offset = ndr->offset;
3399                                 }
3400                                 ndr->offset = _relative_save_offset;
3401                         }
3402                         ndr->flags = _flags_save_string;
3403                 }
3404                 {
3405                         uint32_t _flags_save_string = ndr->flags;
3406                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3407                         if (r->server_name) {
3408                                 uint32_t _relative_save_offset;
3409                                 _relative_save_offset = ndr->offset;
3410                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3411                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3412                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3413                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3414                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3415                                 if (ndr->offset > ndr->relative_highest_offset) {
3416                                         ndr->relative_highest_offset = ndr->offset;
3417                                 }
3418                                 ndr->offset = _relative_save_offset;
3419                         }
3420                         ndr->flags = _flags_save_string;
3421                 }
3422                 {
3423                         uint32_t _flags_save_string = ndr->flags;
3424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3425                         if (r->user_name) {
3426                                 uint32_t _relative_save_offset;
3427                                 _relative_save_offset = ndr->offset;
3428                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3429                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3430                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3431                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3432                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3433                                 if (ndr->offset > ndr->relative_highest_offset) {
3434                                         ndr->relative_highest_offset = ndr->offset;
3435                                 }
3436                                 ndr->offset = _relative_save_offset;
3437                         }
3438                         ndr->flags = _flags_save_string;
3439                 }
3440                 {
3441                         uint32_t _flags_save_string = ndr->flags;
3442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3443                         if (r->document_name) {
3444                                 uint32_t _relative_save_offset;
3445                                 _relative_save_offset = ndr->offset;
3446                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3447                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3448                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3449                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3450                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3451                                 if (ndr->offset > ndr->relative_highest_offset) {
3452                                         ndr->relative_highest_offset = ndr->offset;
3453                                 }
3454                                 ndr->offset = _relative_save_offset;
3455                         }
3456                         ndr->flags = _flags_save_string;
3457                 }
3458                 {
3459                         uint32_t _flags_save_string = ndr->flags;
3460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3461                         if (r->data_type) {
3462                                 uint32_t _relative_save_offset;
3463                                 _relative_save_offset = ndr->offset;
3464                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3465                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3466                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3467                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3468                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3469                                 if (ndr->offset > ndr->relative_highest_offset) {
3470                                         ndr->relative_highest_offset = ndr->offset;
3471                                 }
3472                                 ndr->offset = _relative_save_offset;
3473                         }
3474                         ndr->flags = _flags_save_string;
3475                 }
3476                 {
3477                         uint32_t _flags_save_string = ndr->flags;
3478                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3479                         if (r->text_status) {
3480                                 uint32_t _relative_save_offset;
3481                                 _relative_save_offset = ndr->offset;
3482                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3483                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3484                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3485                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3486                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3487                                 if (ndr->offset > ndr->relative_highest_offset) {
3488                                         ndr->relative_highest_offset = ndr->offset;
3489                                 }
3490                                 ndr->offset = _relative_save_offset;
3491                         }
3492                         ndr->flags = _flags_save_string;
3493                 }
3494         }
3495         return NDR_ERR_SUCCESS;
3496 }
3497
3498 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
3499 {
3500         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
3501         ndr->depth++;
3502         ndr_print_uint32(ndr, "job_id", r->job_id);
3503         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3504         ndr->depth++;
3505         if (r->printer_name) {
3506                 ndr_print_string(ndr, "printer_name", r->printer_name);
3507         }
3508         ndr->depth--;
3509         ndr_print_ptr(ndr, "server_name", r->server_name);
3510         ndr->depth++;
3511         if (r->server_name) {
3512                 ndr_print_string(ndr, "server_name", r->server_name);
3513         }
3514         ndr->depth--;
3515         ndr_print_ptr(ndr, "user_name", r->user_name);
3516         ndr->depth++;
3517         if (r->user_name) {
3518                 ndr_print_string(ndr, "user_name", r->user_name);
3519         }
3520         ndr->depth--;
3521         ndr_print_ptr(ndr, "document_name", r->document_name);
3522         ndr->depth++;
3523         if (r->document_name) {
3524                 ndr_print_string(ndr, "document_name", r->document_name);
3525         }
3526         ndr->depth--;
3527         ndr_print_ptr(ndr, "data_type", r->data_type);
3528         ndr->depth++;
3529         if (r->data_type) {
3530                 ndr_print_string(ndr, "data_type", r->data_type);
3531         }
3532         ndr->depth--;
3533         ndr_print_ptr(ndr, "text_status", r->text_status);
3534         ndr->depth++;
3535         if (r->text_status) {
3536                 ndr_print_string(ndr, "text_status", r->text_status);
3537         }
3538         ndr->depth--;
3539         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3540         ndr_print_uint32(ndr, "priority", r->priority);
3541         ndr_print_uint32(ndr, "position", r->position);
3542         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3543         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3544         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3545         ndr->depth--;
3546 }
3547
3548 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
3549 {
3550         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
3551 }
3552
3553 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
3554 {
3555         if (ndr_flags & NDR_SCALARS) {
3556                 NDR_CHECK(ndr_push_align(ndr, 5));
3557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3558                 {
3559                         uint32_t _flags_save_string = ndr->flags;
3560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3561                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3562                         ndr->flags = _flags_save_string;
3563                 }
3564                 {
3565                         uint32_t _flags_save_string = ndr->flags;
3566                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3567                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3568                         ndr->flags = _flags_save_string;
3569                 }
3570                 {
3571                         uint32_t _flags_save_string = ndr->flags;
3572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3573                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3574                         ndr->flags = _flags_save_string;
3575                 }
3576                 {
3577                         uint32_t _flags_save_string = ndr->flags;
3578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3579                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3580                         ndr->flags = _flags_save_string;
3581                 }
3582                 {
3583                         uint32_t _flags_save_string = ndr->flags;
3584                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3585                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3586                         ndr->flags = _flags_save_string;
3587                 }
3588                 {
3589                         uint32_t _flags_save_string = ndr->flags;
3590                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3591                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3592                         ndr->flags = _flags_save_string;
3593                 }
3594                 {
3595                         uint32_t _flags_save_string = ndr->flags;
3596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3597                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3598                         ndr->flags = _flags_save_string;
3599                 }
3600                 {
3601                         uint32_t _flags_save_string = ndr->flags;
3602                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3603                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3604                         ndr->flags = _flags_save_string;
3605                 }
3606                 {
3607                         uint32_t _flags_save_string = ndr->flags;
3608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3609                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3610                         ndr->flags = _flags_save_string;
3611                 }
3612                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3613                 {
3614                         uint32_t _flags_save_string = ndr->flags;
3615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3616                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3617                         ndr->flags = _flags_save_string;
3618                 }
3619                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3620                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3621                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3622                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3627                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3630                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3631         }
3632         if (ndr_flags & NDR_BUFFERS) {
3633                 {
3634                         uint32_t _flags_save_string = ndr->flags;
3635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3636                         if (r->printer_name) {
3637                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3638                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3639                         }
3640                         ndr->flags = _flags_save_string;
3641                 }
3642                 {
3643                         uint32_t _flags_save_string = ndr->flags;
3644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3645                         if (r->server_name) {
3646                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3647                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3648                         }
3649                         ndr->flags = _flags_save_string;
3650                 }
3651                 {
3652                         uint32_t _flags_save_string = ndr->flags;
3653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3654                         if (r->user_name) {
3655                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3656                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3657                         }
3658                         ndr->flags = _flags_save_string;
3659                 }
3660                 {
3661                         uint32_t _flags_save_string = ndr->flags;
3662                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3663                         if (r->document_name) {
3664                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3665                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3666                         }
3667                         ndr->flags = _flags_save_string;
3668                 }
3669                 {
3670                         uint32_t _flags_save_string = ndr->flags;
3671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3672                         if (r->notify_name) {
3673                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3674                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3675                         }
3676                         ndr->flags = _flags_save_string;
3677                 }
3678                 {
3679                         uint32_t _flags_save_string = ndr->flags;
3680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3681                         if (r->data_type) {
3682                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3683                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3684                         }
3685                         ndr->flags = _flags_save_string;
3686                 }
3687                 {
3688                         uint32_t _flags_save_string = ndr->flags;
3689                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3690                         if (r->print_processor) {
3691                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3692                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3693                         }
3694                         ndr->flags = _flags_save_string;
3695                 }
3696                 {
3697                         uint32_t _flags_save_string = ndr->flags;
3698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3699                         if (r->parameters) {
3700                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3701                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3702                         }
3703                         ndr->flags = _flags_save_string;
3704                 }
3705                 {
3706                         uint32_t _flags_save_string = ndr->flags;
3707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3708                         if (r->driver_name) {
3709                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3710                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3711                         }
3712                         ndr->flags = _flags_save_string;
3713                 }
3714                 if (r->devmode) {
3715                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3716                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3717                 }
3718                 {
3719                         uint32_t _flags_save_string = ndr->flags;
3720                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3721                         if (r->text_status) {
3722                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3723                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3724                         }
3725                         ndr->flags = _flags_save_string;
3726                 }
3727                 if (r->secdesc) {
3728                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3729                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3730                 }
3731         }
3732         return NDR_ERR_SUCCESS;
3733 }
3734
3735 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3736 {
3737         uint32_t _ptr_printer_name;
3738         TALLOC_CTX *_mem_save_printer_name_0;
3739         uint32_t _ptr_server_name;
3740         TALLOC_CTX *_mem_save_server_name_0;
3741         uint32_t _ptr_user_name;
3742         TALLOC_CTX *_mem_save_user_name_0;
3743         uint32_t _ptr_document_name;
3744         TALLOC_CTX *_mem_save_document_name_0;
3745         uint32_t _ptr_notify_name;
3746         TALLOC_CTX *_mem_save_notify_name_0;
3747         uint32_t _ptr_data_type;
3748         TALLOC_CTX *_mem_save_data_type_0;
3749         uint32_t _ptr_print_processor;
3750         TALLOC_CTX *_mem_save_print_processor_0;
3751         uint32_t _ptr_parameters;
3752         TALLOC_CTX *_mem_save_parameters_0;
3753         uint32_t _ptr_driver_name;
3754         TALLOC_CTX *_mem_save_driver_name_0;
3755         uint32_t _ptr_devmode;
3756         TALLOC_CTX *_mem_save_devmode_0;
3757         uint32_t _ptr_text_status;
3758         TALLOC_CTX *_mem_save_text_status_0;
3759         uint32_t _ptr_secdesc;
3760         TALLOC_CTX *_mem_save_secdesc_0;
3761         if (ndr_flags & NDR_SCALARS) {
3762                 NDR_CHECK(ndr_pull_align(ndr, 5));
3763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3764                 {
3765                         uint32_t _flags_save_string = ndr->flags;
3766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3767                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3768                         if (_ptr_printer_name) {
3769                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3770                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3771                         } else {
3772                                 r->printer_name = NULL;
3773                         }
3774                         ndr->flags = _flags_save_string;
3775                 }
3776                 {
3777                         uint32_t _flags_save_string = ndr->flags;
3778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3779                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3780                         if (_ptr_server_name) {
3781                                 NDR_PULL_ALLOC(ndr, r->server_name);
3782                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3783                         } else {
3784                                 r->server_name = NULL;
3785                         }
3786                         ndr->flags = _flags_save_string;
3787                 }
3788                 {
3789                         uint32_t _flags_save_string = ndr->flags;
3790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3791                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3792                         if (_ptr_user_name) {
3793                                 NDR_PULL_ALLOC(ndr, r->user_name);
3794                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3795                         } else {
3796                                 r->user_name = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3804                         if (_ptr_document_name) {
3805                                 NDR_PULL_ALLOC(ndr, r->document_name);
3806                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3807                         } else {
3808                                 r->document_name = NULL;
3809                         }
3810                         ndr->flags = _flags_save_string;
3811                 }
3812                 {
3813                         uint32_t _flags_save_string = ndr->flags;
3814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3815                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3816                         if (_ptr_notify_name) {
3817                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3818                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3819                         } else {
3820                                 r->notify_name = NULL;
3821                         }
3822                         ndr->flags = _flags_save_string;
3823                 }
3824                 {
3825                         uint32_t _flags_save_string = ndr->flags;
3826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3827                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3828                         if (_ptr_data_type) {
3829                                 NDR_PULL_ALLOC(ndr, r->data_type);
3830                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3831                         } else {
3832                                 r->data_type = NULL;
3833                         }
3834                         ndr->flags = _flags_save_string;
3835                 }
3836                 {
3837                         uint32_t _flags_save_string = ndr->flags;
3838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3839                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3840                         if (_ptr_print_processor) {
3841                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3842                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3843                         } else {
3844                                 r->print_processor = NULL;
3845                         }
3846                         ndr->flags = _flags_save_string;
3847                 }
3848                 {
3849                         uint32_t _flags_save_string = ndr->flags;
3850                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3851                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3852                         if (_ptr_parameters) {
3853                                 NDR_PULL_ALLOC(ndr, r->parameters);
3854                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3855                         } else {
3856                                 r->parameters = NULL;
3857                         }
3858                         ndr->flags = _flags_save_string;
3859                 }
3860                 {
3861                         uint32_t _flags_save_string = ndr->flags;
3862                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3863                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3864                         if (_ptr_driver_name) {
3865                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3866                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3867                         } else {
3868                                 r->driver_name = NULL;
3869                         }
3870                         ndr->flags = _flags_save_string;
3871                 }
3872                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3873                 if (_ptr_devmode) {
3874                         NDR_PULL_ALLOC(ndr, r->devmode);
3875                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3876                 } else {
3877                         r->devmode = NULL;
3878                 }
3879                 {
3880                         uint32_t _flags_save_string = ndr->flags;
3881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3882                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3883                         if (_ptr_text_status) {
3884                                 NDR_PULL_ALLOC(ndr, r->text_status);
3885                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3886                         } else {
3887                                 r->text_status = NULL;
3888                         }
3889                         ndr->flags = _flags_save_string;
3890                 }
3891                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3892                 if (_ptr_secdesc) {
3893                         NDR_PULL_ALLOC(ndr, r->secdesc);
3894                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3895                 } else {
3896                         r->secdesc = NULL;
3897                 }
3898                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3900                 if (r->priority > 99) {
3901                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3902                 }
3903                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3904                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3905                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3906                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3907                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3908                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3910                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3911                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3912         }
3913         if (ndr_flags & NDR_BUFFERS) {
3914                 {
3915                         uint32_t _flags_save_string = ndr->flags;
3916                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3917                         if (r->printer_name) {
3918                                 uint32_t _relative_save_offset;
3919                                 _relative_save_offset = ndr->offset;
3920                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3921                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3922                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3923                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3924                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3925                                 if (ndr->offset > ndr->relative_highest_offset) {
3926                                         ndr->relative_highest_offset = ndr->offset;
3927                                 }
3928                                 ndr->offset = _relative_save_offset;
3929                         }
3930                         ndr->flags = _flags_save_string;
3931                 }
3932                 {
3933                         uint32_t _flags_save_string = ndr->flags;
3934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3935                         if (r->server_name) {
3936                                 uint32_t _relative_save_offset;
3937                                 _relative_save_offset = ndr->offset;
3938                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3939                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3940                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3941                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3942                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3943                                 if (ndr->offset > ndr->relative_highest_offset) {
3944                                         ndr->relative_highest_offset = ndr->offset;
3945                                 }
3946                                 ndr->offset = _relative_save_offset;
3947                         }
3948                         ndr->flags = _flags_save_string;
3949                 }
3950                 {
3951                         uint32_t _flags_save_string = ndr->flags;
3952                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3953                         if (r->user_name) {
3954                                 uint32_t _relative_save_offset;
3955                                 _relative_save_offset = ndr->offset;
3956                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3957                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3958                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3959                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3960                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3961                                 if (ndr->offset > ndr->relative_highest_offset) {
3962                                         ndr->relative_highest_offset = ndr->offset;
3963                                 }
3964                                 ndr->offset = _relative_save_offset;
3965                         }
3966                         ndr->flags = _flags_save_string;
3967                 }
3968                 {
3969                         uint32_t _flags_save_string = ndr->flags;
3970                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3971                         if (r->document_name) {
3972                                 uint32_t _relative_save_offset;
3973                                 _relative_save_offset = ndr->offset;
3974                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3975                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3976                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3977                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3978                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3979                                 if (ndr->offset > ndr->relative_highest_offset) {
3980                                         ndr->relative_highest_offset = ndr->offset;
3981                                 }
3982                                 ndr->offset = _relative_save_offset;
3983                         }
3984                         ndr->flags = _flags_save_string;
3985                 }
3986                 {
3987                         uint32_t _flags_save_string = ndr->flags;
3988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3989                         if (r->notify_name) {
3990                                 uint32_t _relative_save_offset;
3991                                 _relative_save_offset = ndr->offset;
3992                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3993                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3994                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3995                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3996                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3997                                 if (ndr->offset > ndr->relative_highest_offset) {
3998                                         ndr->relative_highest_offset = ndr->offset;
3999                                 }
4000                                 ndr->offset = _relative_save_offset;
4001                         }
4002                         ndr->flags = _flags_save_string;
4003                 }
4004                 {
4005                         uint32_t _flags_save_string = ndr->flags;
4006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4007                         if (r->data_type) {
4008                                 uint32_t _relative_save_offset;
4009                                 _relative_save_offset = ndr->offset;
4010                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4011                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4012                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4013                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4014                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4015                                 if (ndr->offset > ndr->relative_highest_offset) {
4016                                         ndr->relative_highest_offset = ndr->offset;
4017                                 }
4018                                 ndr->offset = _relative_save_offset;
4019                         }
4020                         ndr->flags = _flags_save_string;
4021                 }
4022                 {
4023                         uint32_t _flags_save_string = ndr->flags;
4024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4025                         if (r->print_processor) {
4026                                 uint32_t _relative_save_offset;
4027                                 _relative_save_offset = ndr->offset;
4028                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4029                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4030                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4031                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4032                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4033                                 if (ndr->offset > ndr->relative_highest_offset) {
4034                                         ndr->relative_highest_offset = ndr->offset;
4035                                 }
4036                                 ndr->offset = _relative_save_offset;
4037                         }
4038                         ndr->flags = _flags_save_string;
4039                 }
4040                 {
4041                         uint32_t _flags_save_string = ndr->flags;
4042                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4043                         if (r->parameters) {
4044                                 uint32_t _relative_save_offset;
4045                                 _relative_save_offset = ndr->offset;
4046                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4047                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4048                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4049                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4050                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4051                                 if (ndr->offset > ndr->relative_highest_offset) {
4052                                         ndr->relative_highest_offset = ndr->offset;
4053                                 }
4054                                 ndr->offset = _relative_save_offset;
4055                         }
4056                         ndr->flags = _flags_save_string;
4057                 }
4058                 {
4059                         uint32_t _flags_save_string = ndr->flags;
4060                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4061                         if (r->driver_name) {
4062                                 uint32_t _relative_save_offset;
4063                                 _relative_save_offset = ndr->offset;
4064                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4065                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4066                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4067                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4068                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4069                                 if (ndr->offset > ndr->relative_highest_offset) {
4070                                         ndr->relative_highest_offset = ndr->offset;
4071                                 }
4072                                 ndr->offset = _relative_save_offset;
4073                         }
4074                         ndr->flags = _flags_save_string;
4075                 }
4076                 if (r->devmode) {
4077                         uint32_t _relative_save_offset;
4078                         _relative_save_offset = ndr->offset;
4079                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4080                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4081                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4082                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4083                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4084                         if (ndr->offset > ndr->relative_highest_offset) {
4085                                 ndr->relative_highest_offset = ndr->offset;
4086                         }
4087                         ndr->offset = _relative_save_offset;
4088                 }
4089                 {
4090                         uint32_t _flags_save_string = ndr->flags;
4091                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4092                         if (r->text_status) {
4093                                 uint32_t _relative_save_offset;
4094                                 _relative_save_offset = ndr->offset;
4095                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4096                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4097                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4098                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4099                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4100                                 if (ndr->offset > ndr->relative_highest_offset) {
4101                                         ndr->relative_highest_offset = ndr->offset;
4102                                 }
4103                                 ndr->offset = _relative_save_offset;
4104                         }
4105                         ndr->flags = _flags_save_string;
4106                 }
4107                 if (r->secdesc) {
4108                         uint32_t _relative_save_offset;
4109                         _relative_save_offset = ndr->offset;
4110                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4111                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4112                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4113                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4114                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4115                         if (ndr->offset > ndr->relative_highest_offset) {
4116                                 ndr->relative_highest_offset = ndr->offset;
4117                         }
4118                         ndr->offset = _relative_save_offset;
4119                 }
4120         }
4121         return NDR_ERR_SUCCESS;
4122 }
4123
4124 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
4125 {
4126         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
4127         ndr->depth++;
4128         ndr_print_uint32(ndr, "job_id", r->job_id);
4129         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4130         ndr->depth++;
4131         if (r->printer_name) {
4132                 ndr_print_string(ndr, "printer_name", r->printer_name);
4133         }
4134         ndr->depth--;
4135         ndr_print_ptr(ndr, "server_name", r->server_name);
4136         ndr->depth++;
4137         if (r->server_name) {
4138                 ndr_print_string(ndr, "server_name", r->server_name);
4139         }
4140         ndr->depth--;
4141         ndr_print_ptr(ndr, "user_name", r->user_name);
4142         ndr->depth++;
4143         if (r->user_name) {
4144                 ndr_print_string(ndr, "user_name", r->user_name);
4145         }
4146         ndr->depth--;
4147         ndr_print_ptr(ndr, "document_name", r->document_name);
4148         ndr->depth++;
4149         if (r->document_name) {
4150                 ndr_print_string(ndr, "document_name", r->document_name);
4151         }
4152         ndr->depth--;
4153         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4154         ndr->depth++;
4155         if (r->notify_name) {
4156                 ndr_print_string(ndr, "notify_name", r->notify_name);
4157         }
4158         ndr->depth--;
4159         ndr_print_ptr(ndr, "data_type", r->data_type);
4160         ndr->depth++;
4161         if (r->data_type) {
4162                 ndr_print_string(ndr, "data_type", r->data_type);
4163         }
4164         ndr->depth--;
4165         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4166         ndr->depth++;
4167         if (r->print_processor) {
4168                 ndr_print_string(ndr, "print_processor", r->print_processor);
4169         }
4170         ndr->depth--;
4171         ndr_print_ptr(ndr, "parameters", r->parameters);
4172         ndr->depth++;
4173         if (r->parameters) {
4174                 ndr_print_string(ndr, "parameters", r->parameters);
4175         }
4176         ndr->depth--;
4177         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4178         ndr->depth++;
4179         if (r->driver_name) {
4180                 ndr_print_string(ndr, "driver_name", r->driver_name);
4181         }
4182         ndr->depth--;
4183         ndr_print_ptr(ndr, "devmode", r->devmode);
4184         ndr->depth++;
4185         if (r->devmode) {
4186                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4187         }
4188         ndr->depth--;
4189         ndr_print_ptr(ndr, "text_status", r->text_status);
4190         ndr->depth++;
4191         if (r->text_status) {
4192                 ndr_print_string(ndr, "text_status", r->text_status);
4193         }
4194         ndr->depth--;
4195         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4196         ndr->depth++;
4197         if (r->secdesc) {
4198                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4199         }
4200         ndr->depth--;
4201         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4202         ndr_print_uint32(ndr, "priority", r->priority);
4203         ndr_print_uint32(ndr, "position", r->position);
4204         ndr_print_uint32(ndr, "start_time", r->start_time);
4205         ndr_print_uint32(ndr, "until_time", r->until_time);
4206         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4207         ndr_print_uint32(ndr, "size", r->size);
4208         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4209         ndr_print_uint32(ndr, "time", r->time);
4210         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4211         ndr->depth--;
4212 }
4213
4214 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
4215 {
4216         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
4217 }
4218
4219 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
4220 {
4221         if (ndr_flags & NDR_SCALARS) {
4222                 NDR_CHECK(ndr_push_align(ndr, 4));
4223                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4224                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
4225                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
4226                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4227         }
4228         if (ndr_flags & NDR_BUFFERS) {
4229         }
4230         return NDR_ERR_SUCCESS;
4231 }
4232
4233 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
4234 {
4235         if (ndr_flags & NDR_SCALARS) {
4236                 NDR_CHECK(ndr_pull_align(ndr, 4));
4237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
4239                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
4240                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4241         }
4242         if (ndr_flags & NDR_BUFFERS) {
4243         }
4244         return NDR_ERR_SUCCESS;
4245 }
4246
4247 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
4248 {
4249         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
4250         ndr->depth++;
4251         ndr_print_uint32(ndr, "job_id", r->job_id);
4252         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
4253         ndr_print_uint32(ndr, "reserved", r->reserved);
4254         ndr->depth--;
4255 }
4256
4257 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
4258 {
4259         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
4260 }
4261
4262 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
4263 {
4264         if (ndr_flags & NDR_SCALARS) {
4265                 NDR_CHECK(ndr_push_align(ndr, 5));
4266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4267                 {
4268                         uint32_t _flags_save_string = ndr->flags;
4269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4270                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
4271                         ndr->flags = _flags_save_string;
4272                 }
4273                 {
4274                         uint32_t _flags_save_string = ndr->flags;
4275                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4276                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
4277                         ndr->flags = _flags_save_string;
4278                 }
4279                 {
4280                         uint32_t _flags_save_string = ndr->flags;
4281                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4282                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
4283                         ndr->flags = _flags_save_string;
4284                 }
4285                 {
4286                         uint32_t _flags_save_string = ndr->flags;
4287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4288                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
4289                         ndr->flags = _flags_save_string;
4290                 }
4291                 {
4292                         uint32_t _flags_save_string = ndr->flags;
4293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4294                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
4295                         ndr->flags = _flags_save_string;
4296                 }
4297                 {
4298                         uint32_t _flags_save_string = ndr->flags;
4299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4300                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
4301                         ndr->flags = _flags_save_string;
4302                 }
4303                 {
4304                         uint32_t _flags_save_string = ndr->flags;
4305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4306                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
4307                         ndr->flags = _flags_save_string;
4308                 }
4309                 {
4310                         uint32_t _flags_save_string = ndr->flags;
4311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4312                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
4313                         ndr->flags = _flags_save_string;
4314                 }
4315                 {
4316                         uint32_t _flags_save_string = ndr->flags;
4317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4318                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
4319                         ndr->flags = _flags_save_string;
4320                 }
4321                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
4322                 {
4323                         uint32_t _flags_save_string = ndr->flags;
4324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4325                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
4326                         ndr->flags = _flags_save_string;
4327                 }
4328                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
4329                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4336                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
4340                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4341         }
4342         if (ndr_flags & NDR_BUFFERS) {
4343                 {
4344                         uint32_t _flags_save_string = ndr->flags;
4345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4346                         if (r->printer_name) {
4347                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
4348                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
4349                         }
4350                         ndr->flags = _flags_save_string;
4351                 }
4352                 {
4353                         uint32_t _flags_save_string = ndr->flags;
4354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4355                         if (r->server_name) {
4356                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
4357                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
4358                         }
4359                         ndr->flags = _flags_save_string;
4360                 }
4361                 {
4362                         uint32_t _flags_save_string = ndr->flags;
4363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4364                         if (r->user_name) {
4365                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
4366                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
4367                         }
4368                         ndr->flags = _flags_save_string;
4369                 }
4370                 {
4371                         uint32_t _flags_save_string = ndr->flags;
4372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4373                         if (r->document_name) {
4374                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
4375                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
4376                         }
4377                         ndr->flags = _flags_save_string;
4378                 }
4379                 {
4380                         uint32_t _flags_save_string = ndr->flags;
4381                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4382                         if (r->notify_name) {
4383                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
4384                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
4385                         }
4386                         ndr->flags = _flags_save_string;
4387                 }
4388                 {
4389                         uint32_t _flags_save_string = ndr->flags;
4390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4391                         if (r->data_type) {
4392                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
4393                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
4394                         }
4395                         ndr->flags = _flags_save_string;
4396                 }
4397                 {
4398                         uint32_t _flags_save_string = ndr->flags;
4399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4400                         if (r->print_processor) {
4401                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
4402                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
4403                         }
4404                         ndr->flags = _flags_save_string;
4405                 }
4406                 {
4407                         uint32_t _flags_save_string = ndr->flags;
4408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4409                         if (r->parameters) {
4410                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
4411                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
4412                         }
4413                         ndr->flags = _flags_save_string;
4414                 }
4415                 {
4416                         uint32_t _flags_save_string = ndr->flags;
4417                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4418                         if (r->driver_name) {
4419                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
4420                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
4421                         }
4422                         ndr->flags = _flags_save_string;
4423                 }
4424                 if (r->devmode) {
4425                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
4426                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4427                 }
4428                 {
4429                         uint32_t _flags_save_string = ndr->flags;
4430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4431                         if (r->text_status) {
4432                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
4433                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
4434                         }
4435                         ndr->flags = _flags_save_string;
4436                 }
4437                 if (r->secdesc) {
4438                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
4439                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4440                 }
4441         }
4442         return NDR_ERR_SUCCESS;
4443 }
4444
4445 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
4446 {
4447         uint32_t _ptr_printer_name;
4448         TALLOC_CTX *_mem_save_printer_name_0;
4449         uint32_t _ptr_server_name;
4450         TALLOC_CTX *_mem_save_server_name_0;
4451         uint32_t _ptr_user_name;
4452         TALLOC_CTX *_mem_save_user_name_0;
4453         uint32_t _ptr_document_name;
4454         TALLOC_CTX *_mem_save_document_name_0;
4455         uint32_t _ptr_notify_name;
4456         TALLOC_CTX *_mem_save_notify_name_0;
4457         uint32_t _ptr_data_type;
4458         TALLOC_CTX *_mem_save_data_type_0;
4459         uint32_t _ptr_print_processor;
4460         TALLOC_CTX *_mem_save_print_processor_0;
4461         uint32_t _ptr_parameters;
4462         TALLOC_CTX *_mem_save_parameters_0;
4463         uint32_t _ptr_driver_name;
4464         TALLOC_CTX *_mem_save_driver_name_0;
4465         uint32_t _ptr_devmode;
4466         TALLOC_CTX *_mem_save_devmode_0;
4467         uint32_t _ptr_text_status;
4468         TALLOC_CTX *_mem_save_text_status_0;
4469         uint32_t _ptr_secdesc;
4470         TALLOC_CTX *_mem_save_secdesc_0;
4471         if (ndr_flags & NDR_SCALARS) {
4472                 NDR_CHECK(ndr_pull_align(ndr, 5));
4473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4474                 {
4475                         uint32_t _flags_save_string = ndr->flags;
4476                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4477                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4478                         if (_ptr_printer_name) {
4479                                 NDR_PULL_ALLOC(ndr, r->printer_name);
4480                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
4481                         } else {
4482                                 r->printer_name = NULL;
4483                         }
4484                         ndr->flags = _flags_save_string;
4485                 }
4486                 {
4487                         uint32_t _flags_save_string = ndr->flags;
4488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4489                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4490                         if (_ptr_server_name) {
4491                                 NDR_PULL_ALLOC(ndr, r->server_name);
4492                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
4493                         } else {
4494                                 r->server_name = NULL;
4495                         }
4496                         ndr->flags = _flags_save_string;
4497                 }
4498                 {
4499                         uint32_t _flags_save_string = ndr->flags;
4500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4501                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4502                         if (_ptr_user_name) {
4503                                 NDR_PULL_ALLOC(ndr, r->user_name);
4504                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
4505                         } else {
4506                                 r->user_name = NULL;
4507                         }
4508                         ndr->flags = _flags_save_string;
4509                 }
4510                 {
4511                         uint32_t _flags_save_string = ndr->flags;
4512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4513                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4514                         if (_ptr_document_name) {
4515                                 NDR_PULL_ALLOC(ndr, r->document_name);
4516                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
4517                         } else {
4518                                 r->document_name = NULL;
4519                         }
4520                         ndr->flags = _flags_save_string;
4521                 }
4522                 {
4523                         uint32_t _flags_save_string = ndr->flags;
4524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4525                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4526                         if (_ptr_notify_name) {
4527                                 NDR_PULL_ALLOC(ndr, r->notify_name);
4528                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
4529                         } else {
4530                                 r->notify_name = NULL;
4531                         }
4532                         ndr->flags = _flags_save_string;
4533                 }
4534                 {
4535                         uint32_t _flags_save_string = ndr->flags;
4536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4537                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4538                         if (_ptr_data_type) {
4539                                 NDR_PULL_ALLOC(ndr, r->data_type);
4540                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
4541                         } else {
4542                                 r->data_type = NULL;
4543                         }
4544                         ndr->flags = _flags_save_string;
4545                 }
4546                 {
4547                         uint32_t _flags_save_string = ndr->flags;
4548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4549                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4550                         if (_ptr_print_processor) {
4551                                 NDR_PULL_ALLOC(ndr, r->print_processor);
4552                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
4553                         } else {
4554                                 r->print_processor = NULL;
4555                         }
4556                         ndr->flags = _flags_save_string;
4557                 }
4558                 {
4559                         uint32_t _flags_save_string = ndr->flags;
4560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4561                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4562                         if (_ptr_parameters) {
4563                                 NDR_PULL_ALLOC(ndr, r->parameters);
4564                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
4565                         } else {
4566                                 r->parameters = NULL;
4567                         }
4568                         ndr->flags = _flags_save_string;
4569                 }
4570                 {
4571                         uint32_t _flags_save_string = ndr->flags;
4572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4573                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4574                         if (_ptr_driver_name) {
4575                                 NDR_PULL_ALLOC(ndr, r->driver_name);
4576                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
4577                         } else {
4578                                 r->driver_name = NULL;
4579                         }
4580                         ndr->flags = _flags_save_string;
4581                 }
4582                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
4583                 if (_ptr_devmode) {
4584                         NDR_PULL_ALLOC(ndr, r->devmode);
4585                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
4586                 } else {
4587                         r->devmode = NULL;
4588                 }
4589                 {
4590                         uint32_t _flags_save_string = ndr->flags;
4591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4592                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4593                         if (_ptr_text_status) {
4594                                 NDR_PULL_ALLOC(ndr, r->text_status);
4595                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
4596                         } else {
4597                                 r->text_status = NULL;
4598                         }
4599                         ndr->flags = _flags_save_string;
4600                 }
4601                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
4602                 if (_ptr_secdesc) {
4603                         NDR_PULL_ALLOC(ndr, r->secdesc);
4604                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
4605                 } else {
4606                         r->secdesc = NULL;
4607                 }
4608                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4610                 if (r->priority > 99) {
4611                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4612                 }
4613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4615                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4616                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4617                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4618                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4619                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4621                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
4622                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4623         }
4624         if (ndr_flags & NDR_BUFFERS) {
4625                 {
4626                         uint32_t _flags_save_string = ndr->flags;
4627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4628                         if (r->printer_name) {
4629                                 uint32_t _relative_save_offset;
4630                                 _relative_save_offset = ndr->offset;
4631                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
4632                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4633                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4634                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
4635                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4636                                 if (ndr->offset > ndr->relative_highest_offset) {
4637                                         ndr->relative_highest_offset = ndr->offset;
4638                                 }
4639                                 ndr->offset = _relative_save_offset;
4640                         }
4641                         ndr->flags = _flags_save_string;
4642                 }
4643                 {
4644                         uint32_t _flags_save_string = ndr->flags;
4645                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4646                         if (r->server_name) {
4647                                 uint32_t _relative_save_offset;
4648                                 _relative_save_offset = ndr->offset;
4649                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4650                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4651                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4652                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4653                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4654                                 if (ndr->offset > ndr->relative_highest_offset) {
4655                                         ndr->relative_highest_offset = ndr->offset;
4656                                 }
4657                                 ndr->offset = _relative_save_offset;
4658                         }
4659                         ndr->flags = _flags_save_string;
4660                 }
4661                 {
4662                         uint32_t _flags_save_string = ndr->flags;
4663                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4664                         if (r->user_name) {
4665                                 uint32_t _relative_save_offset;
4666                                 _relative_save_offset = ndr->offset;
4667                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4668                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4669                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4670                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4671                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4672                                 if (ndr->offset > ndr->relative_highest_offset) {
4673                                         ndr->relative_highest_offset = ndr->offset;
4674                                 }
4675                                 ndr->offset = _relative_save_offset;
4676                         }
4677                         ndr->flags = _flags_save_string;
4678                 }
4679                 {
4680                         uint32_t _flags_save_string = ndr->flags;
4681                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4682                         if (r->document_name) {
4683                                 uint32_t _relative_save_offset;
4684                                 _relative_save_offset = ndr->offset;
4685                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4686                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4687                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4688                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4689                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4690                                 if (ndr->offset > ndr->relative_highest_offset) {
4691                                         ndr->relative_highest_offset = ndr->offset;
4692                                 }
4693                                 ndr->offset = _relative_save_offset;
4694                         }
4695                         ndr->flags = _flags_save_string;
4696                 }
4697                 {
4698                         uint32_t _flags_save_string = ndr->flags;
4699                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4700                         if (r->notify_name) {
4701                                 uint32_t _relative_save_offset;
4702                                 _relative_save_offset = ndr->offset;
4703                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4704                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4705                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4706                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4707                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4708                                 if (ndr->offset > ndr->relative_highest_offset) {
4709                                         ndr->relative_highest_offset = ndr->offset;
4710                                 }
4711                                 ndr->offset = _relative_save_offset;
4712                         }
4713                         ndr->flags = _flags_save_string;
4714                 }
4715                 {
4716                         uint32_t _flags_save_string = ndr->flags;
4717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4718                         if (r->data_type) {
4719                                 uint32_t _relative_save_offset;
4720                                 _relative_save_offset = ndr->offset;
4721                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4722                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4723                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4724                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4725                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4726                                 if (ndr->offset > ndr->relative_highest_offset) {
4727                                         ndr->relative_highest_offset = ndr->offset;
4728                                 }
4729                                 ndr->offset = _relative_save_offset;
4730                         }
4731                         ndr->flags = _flags_save_string;
4732                 }
4733                 {
4734                         uint32_t _flags_save_string = ndr->flags;
4735                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4736                         if (r->print_processor) {
4737                                 uint32_t _relative_save_offset;
4738                                 _relative_save_offset = ndr->offset;
4739                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4740                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4741                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4742                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4743                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4744                                 if (ndr->offset > ndr->relative_highest_offset) {
4745                                         ndr->relative_highest_offset = ndr->offset;
4746                                 }
4747                                 ndr->offset = _relative_save_offset;
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                         if (r->parameters) {
4755                                 uint32_t _relative_save_offset;
4756                                 _relative_save_offset = ndr->offset;
4757                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4758                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4759                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4760                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4761                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4762                                 if (ndr->offset > ndr->relative_highest_offset) {
4763                                         ndr->relative_highest_offset = ndr->offset;
4764                                 }
4765                                 ndr->offset = _relative_save_offset;
4766                         }
4767                         ndr->flags = _flags_save_string;
4768                 }
4769                 {
4770                         uint32_t _flags_save_string = ndr->flags;
4771                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4772                         if (r->driver_name) {
4773                                 uint32_t _relative_save_offset;
4774                                 _relative_save_offset = ndr->offset;
4775                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4776                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4777                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4778                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4779                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4780                                 if (ndr->offset > ndr->relative_highest_offset) {
4781                                         ndr->relative_highest_offset = ndr->offset;
4782                                 }
4783                                 ndr->offset = _relative_save_offset;
4784                         }
4785                         ndr->flags = _flags_save_string;
4786                 }
4787                 if (r->devmode) {
4788                         uint32_t _relative_save_offset;
4789                         _relative_save_offset = ndr->offset;
4790                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4791                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4792                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4793                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4794                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4795                         if (ndr->offset > ndr->relative_highest_offset) {
4796                                 ndr->relative_highest_offset = ndr->offset;
4797                         }
4798                         ndr->offset = _relative_save_offset;
4799                 }
4800                 {
4801                         uint32_t _flags_save_string = ndr->flags;
4802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4803                         if (r->text_status) {
4804                                 uint32_t _relative_save_offset;
4805                                 _relative_save_offset = ndr->offset;
4806                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4807                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4808                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4809                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4810                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4811                                 if (ndr->offset > ndr->relative_highest_offset) {
4812                                         ndr->relative_highest_offset = ndr->offset;
4813                                 }
4814                                 ndr->offset = _relative_save_offset;
4815                         }
4816                         ndr->flags = _flags_save_string;
4817                 }
4818                 if (r->secdesc) {
4819                         uint32_t _relative_save_offset;
4820                         _relative_save_offset = ndr->offset;
4821                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4822                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4823                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4824                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4825                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4826                         if (ndr->offset > ndr->relative_highest_offset) {
4827                                 ndr->relative_highest_offset = ndr->offset;
4828                         }
4829                         ndr->offset = _relative_save_offset;
4830                 }
4831         }
4832         return NDR_ERR_SUCCESS;
4833 }
4834
4835 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4836 {
4837         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4838         ndr->depth++;
4839         ndr_print_uint32(ndr, "job_id", r->job_id);
4840         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4841         ndr->depth++;
4842         if (r->printer_name) {
4843                 ndr_print_string(ndr, "printer_name", r->printer_name);
4844         }
4845         ndr->depth--;
4846         ndr_print_ptr(ndr, "server_name", r->server_name);
4847         ndr->depth++;
4848         if (r->server_name) {
4849                 ndr_print_string(ndr, "server_name", r->server_name);
4850         }
4851         ndr->depth--;
4852         ndr_print_ptr(ndr, "user_name", r->user_name);
4853         ndr->depth++;
4854         if (r->user_name) {
4855                 ndr_print_string(ndr, "user_name", r->user_name);
4856         }
4857         ndr->depth--;
4858         ndr_print_ptr(ndr, "document_name", r->document_name);
4859         ndr->depth++;
4860         if (r->document_name) {
4861                 ndr_print_string(ndr, "document_name", r->document_name);
4862         }
4863         ndr->depth--;
4864         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4865         ndr->depth++;
4866         if (r->notify_name) {
4867                 ndr_print_string(ndr, "notify_name", r->notify_name);
4868         }
4869         ndr->depth--;
4870         ndr_print_ptr(ndr, "data_type", r->data_type);
4871         ndr->depth++;
4872         if (r->data_type) {
4873                 ndr_print_string(ndr, "data_type", r->data_type);
4874         }
4875         ndr->depth--;
4876         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4877         ndr->depth++;
4878         if (r->print_processor) {
4879                 ndr_print_string(ndr, "print_processor", r->print_processor);
4880         }
4881         ndr->depth--;
4882         ndr_print_ptr(ndr, "parameters", r->parameters);
4883         ndr->depth++;
4884         if (r->parameters) {
4885                 ndr_print_string(ndr, "parameters", r->parameters);
4886         }
4887         ndr->depth--;
4888         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4889         ndr->depth++;
4890         if (r->driver_name) {
4891                 ndr_print_string(ndr, "driver_name", r->driver_name);
4892         }
4893         ndr->depth--;
4894         ndr_print_ptr(ndr, "devmode", r->devmode);
4895         ndr->depth++;
4896         if (r->devmode) {
4897                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4898         }
4899         ndr->depth--;
4900         ndr_print_ptr(ndr, "text_status", r->text_status);
4901         ndr->depth++;
4902         if (r->text_status) {
4903                 ndr_print_string(ndr, "text_status", r->text_status);
4904         }
4905         ndr->depth--;
4906         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4907         ndr->depth++;
4908         if (r->secdesc) {
4909                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4910         }
4911         ndr->depth--;
4912         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4913         ndr_print_uint32(ndr, "priority", r->priority);
4914         ndr_print_uint32(ndr, "position", r->position);
4915         ndr_print_uint32(ndr, "start_time", r->start_time);
4916         ndr_print_uint32(ndr, "until_time", r->until_time);
4917         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4918         ndr_print_uint32(ndr, "size", r->size);
4919         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4920         ndr_print_uint32(ndr, "time", r->time);
4921         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4922         ndr_print_uint32(ndr, "size_high", r->size_high);
4923         ndr->depth--;
4924 }
4925
4926 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
4927 {
4928         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
4929 }
4930
4931 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4932 {
4933         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4934         if (ndr_flags & NDR_SCALARS) {
4935                 int level = ndr_push_get_switch_value(ndr, r);
4936                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4937                 switch (level) {
4938                         case 1: {
4939                                 NDR_CHECK(ndr_push_align(ndr, 5));
4940                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4941                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4942                         break; }
4943
4944                         case 2: {
4945                                 NDR_CHECK(ndr_push_align(ndr, 5));
4946                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4947                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4948                         break; }
4949
4950                         case 3: {
4951                                 NDR_CHECK(ndr_push_align(ndr, 4));
4952                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4953                                 NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4954                         break; }
4955
4956                         case 4: {
4957                                 NDR_CHECK(ndr_push_align(ndr, 5));
4958                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4959                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4960                         break; }
4961
4962                         default: {
4963                         break; }
4964
4965                 }
4966         }
4967         if (ndr_flags & NDR_BUFFERS) {
4968                 int level = ndr_push_get_switch_value(ndr, r);
4969                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4970                 switch (level) {
4971                         case 1:
4972                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4973                         break;
4974
4975                         case 2:
4976                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4977                         break;
4978
4979                         case 3:
4980                         break;
4981
4982                         case 4:
4983                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4984                         break;
4985
4986                         default:
4987                         break;
4988
4989                 }
4990         }
4991         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4992         return NDR_ERR_SUCCESS;
4993 }
4994
4995 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4996 {
4997         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4998         int level;
4999         level = ndr_pull_get_switch_value(ndr, r);
5000         if (ndr_flags & NDR_SCALARS) {
5001                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5002                 switch (level) {
5003                         case 1: {
5004                                 NDR_CHECK(ndr_pull_align(ndr, 5));
5005                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5006                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
5007                         break; }
5008
5009                         case 2: {
5010                                 NDR_CHECK(ndr_pull_align(ndr, 5));
5011                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5012                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
5013                         break; }
5014
5015                         case 3: {
5016                                 NDR_CHECK(ndr_pull_align(ndr, 4));
5017                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5018                                 NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
5019                         break; }
5020
5021                         case 4: {
5022                                 NDR_CHECK(ndr_pull_align(ndr, 5));
5023                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5024                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
5025                         break; }
5026
5027                         default: {
5028                         break; }
5029
5030                 }
5031         }
5032         if (ndr_flags & NDR_BUFFERS) {
5033                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
5034                 switch (level) {
5035                         case 1:
5036                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
5037                         break;
5038
5039                         case 2:
5040                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
5041                         break;
5042
5043                         case 3:
5044                         break;
5045
5046                         case 4:
5047                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
5048                         break;
5049
5050                         default:
5051                         break;
5052
5053                 }
5054         }
5055         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
5056         return NDR_ERR_SUCCESS;
5057 }
5058
5059 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
5060 {
5061         int level;
5062         level = ndr_print_get_switch_value(ndr, r);
5063         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
5064         switch (level) {
5065                 case 1:
5066                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
5067                 break;
5068
5069                 case 2:
5070                         ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
5071                 break;
5072
5073                 case 3:
5074                         ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
5075                 break;
5076
5077                 case 4:
5078                         ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
5079                 break;
5080
5081                 default:
5082                 break;
5083
5084         }
5085 }
5086
5087 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
5088 {
5089         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
5090 }
5091
5092 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
5093 {
5094         if (ndr_flags & NDR_SCALARS) {
5095                 NDR_CHECK(ndr_push_align(ndr, 5));
5096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5097                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5098                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5099                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5100                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5101                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5102                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5103                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5108                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5109                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5110         }
5111         if (ndr_flags & NDR_BUFFERS) {
5112                 if (r->printer_name) {
5113                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5114                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5115                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5116                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5117                 }
5118                 if (r->server_name) {
5119                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5120                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5121                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5122                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5123                 }
5124                 if (r->user_name) {
5125                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5126                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5127                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5128                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5129                 }
5130                 if (r->document_name) {
5131                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5132                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5133                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5134                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5135                 }
5136                 if (r->data_type) {
5137                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5139                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5140                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5141                 }
5142                 if (r->text_status) {
5143                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5144                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5145                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5146                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5147                 }
5148         }
5149         return NDR_ERR_SUCCESS;
5150 }
5151
5152 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
5153 {
5154         uint32_t _ptr_printer_name;
5155         TALLOC_CTX *_mem_save_printer_name_0;
5156         uint32_t _ptr_server_name;
5157         TALLOC_CTX *_mem_save_server_name_0;
5158         uint32_t _ptr_user_name;
5159         TALLOC_CTX *_mem_save_user_name_0;
5160         uint32_t _ptr_document_name;
5161         TALLOC_CTX *_mem_save_document_name_0;
5162         uint32_t _ptr_data_type;
5163         TALLOC_CTX *_mem_save_data_type_0;
5164         uint32_t _ptr_text_status;
5165         TALLOC_CTX *_mem_save_text_status_0;
5166         if (ndr_flags & NDR_SCALARS) {
5167                 NDR_CHECK(ndr_pull_align(ndr, 5));
5168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5170                 if (_ptr_printer_name) {
5171                         NDR_PULL_ALLOC(ndr, r->printer_name);
5172                 } else {
5173                         r->printer_name = NULL;
5174                 }
5175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5176                 if (_ptr_server_name) {
5177                         NDR_PULL_ALLOC(ndr, r->server_name);
5178                 } else {
5179                         r->server_name = NULL;
5180                 }
5181                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5182                 if (_ptr_user_name) {
5183                         NDR_PULL_ALLOC(ndr, r->user_name);
5184                 } else {
5185                         r->user_name = NULL;
5186                 }
5187                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5188                 if (_ptr_document_name) {
5189                         NDR_PULL_ALLOC(ndr, r->document_name);
5190                 } else {
5191                         r->document_name = NULL;
5192                 }
5193                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5194                 if (_ptr_data_type) {
5195                         NDR_PULL_ALLOC(ndr, r->data_type);
5196                 } else {
5197                         r->data_type = NULL;
5198                 }
5199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5200                 if (_ptr_text_status) {
5201                         NDR_PULL_ALLOC(ndr, r->text_status);
5202                 } else {
5203                         r->text_status = NULL;
5204                 }
5205                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5206                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5207                 if (r->priority > 99) {
5208                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5209                 }
5210                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5211                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5212                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5213                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5214                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5215         }
5216         if (ndr_flags & NDR_BUFFERS) {
5217                 if (r->printer_name) {
5218                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5219                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5220                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5221                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5222                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5223                                 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));
5224                         }
5225                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5226                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5227                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5228                 }
5229                 if (r->server_name) {
5230                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5231                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5232                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5233                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5234                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5235                                 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));
5236                         }
5237                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5238                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5240                 }
5241                 if (r->user_name) {
5242                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5243                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5244                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5245                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5246                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5247                                 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));
5248                         }
5249                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5250                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5252                 }
5253                 if (r->document_name) {
5254                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5255                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5256                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5257                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5258                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5259                                 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));
5260                         }
5261                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5262                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5263                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5264                 }
5265                 if (r->data_type) {
5266                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5267                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5268                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5269                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5270                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5271                                 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));
5272                         }
5273                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5274                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5276                 }
5277                 if (r->text_status) {
5278                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5279                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5280                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5281                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5282                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5283                                 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));
5284                         }
5285                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5286                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5288                 }
5289         }
5290         return NDR_ERR_SUCCESS;
5291 }
5292
5293 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
5294 {
5295         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
5296         ndr->depth++;
5297         ndr_print_uint32(ndr, "job_id", r->job_id);
5298         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5299         ndr->depth++;
5300         if (r->printer_name) {
5301                 ndr_print_string(ndr, "printer_name", r->printer_name);
5302         }
5303         ndr->depth--;
5304         ndr_print_ptr(ndr, "server_name", r->server_name);
5305         ndr->depth++;
5306         if (r->server_name) {
5307                 ndr_print_string(ndr, "server_name", r->server_name);
5308         }
5309         ndr->depth--;
5310         ndr_print_ptr(ndr, "user_name", r->user_name);
5311         ndr->depth++;
5312         if (r->user_name) {
5313                 ndr_print_string(ndr, "user_name", r->user_name);
5314         }
5315         ndr->depth--;
5316         ndr_print_ptr(ndr, "document_name", r->document_name);
5317         ndr->depth++;
5318         if (r->document_name) {
5319                 ndr_print_string(ndr, "document_name", r->document_name);
5320         }
5321         ndr->depth--;
5322         ndr_print_ptr(ndr, "data_type", r->data_type);
5323         ndr->depth++;
5324         if (r->data_type) {
5325                 ndr_print_string(ndr, "data_type", r->data_type);
5326         }
5327         ndr->depth--;
5328         ndr_print_ptr(ndr, "text_status", r->text_status);
5329         ndr->depth++;
5330         if (r->text_status) {
5331                 ndr_print_string(ndr, "text_status", r->text_status);
5332         }
5333         ndr->depth--;
5334         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5335         ndr_print_uint32(ndr, "priority", r->priority);
5336         ndr_print_uint32(ndr, "position", r->position);
5337         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5338         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5339         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5340         ndr->depth--;
5341 }
5342
5343 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
5344 {
5345         if (ndr_flags & NDR_SCALARS) {
5346                 NDR_CHECK(ndr_push_align(ndr, 5));
5347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5348                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5349                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5350                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5351                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5352                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5353                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5354                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5355                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5356                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5360                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5361                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5365                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5367                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5368                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5370                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5371         }
5372         if (ndr_flags & NDR_BUFFERS) {
5373                 if (r->printer_name) {
5374                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5375                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5376                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5377                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5378                 }
5379                 if (r->server_name) {
5380                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5381                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5382                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5383                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5384                 }
5385                 if (r->user_name) {
5386                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5387                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5388                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5389                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5390                 }
5391                 if (r->document_name) {
5392                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5393                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5394                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5395                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5396                 }
5397                 if (r->notify_name) {
5398                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5399                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5400                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5401                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5402                 }
5403                 if (r->data_type) {
5404                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5405                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5406                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5407                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5408                 }
5409                 if (r->print_processor) {
5410                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5411                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5412                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5413                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5414                 }
5415                 if (r->parameters) {
5416                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5417                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5418                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5419                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5420                 }
5421                 if (r->driver_name) {
5422                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5423                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5424                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5425                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5426                 }
5427                 if (r->text_status) {
5428                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5429                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5430                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5431                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5432                 }
5433         }
5434         return NDR_ERR_SUCCESS;
5435 }
5436
5437 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
5438 {
5439         uint32_t _ptr_printer_name;
5440         TALLOC_CTX *_mem_save_printer_name_0;
5441         uint32_t _ptr_server_name;
5442         TALLOC_CTX *_mem_save_server_name_0;
5443         uint32_t _ptr_user_name;
5444         TALLOC_CTX *_mem_save_user_name_0;
5445         uint32_t _ptr_document_name;
5446         TALLOC_CTX *_mem_save_document_name_0;
5447         uint32_t _ptr_notify_name;
5448         TALLOC_CTX *_mem_save_notify_name_0;
5449         uint32_t _ptr_data_type;
5450         TALLOC_CTX *_mem_save_data_type_0;
5451         uint32_t _ptr_print_processor;
5452         TALLOC_CTX *_mem_save_print_processor_0;
5453         uint32_t _ptr_parameters;
5454         TALLOC_CTX *_mem_save_parameters_0;
5455         uint32_t _ptr_driver_name;
5456         TALLOC_CTX *_mem_save_driver_name_0;
5457         uint32_t _ptr_text_status;
5458         TALLOC_CTX *_mem_save_text_status_0;
5459         if (ndr_flags & NDR_SCALARS) {
5460                 NDR_CHECK(ndr_pull_align(ndr, 5));
5461                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5462                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5463                 if (_ptr_printer_name) {
5464                         NDR_PULL_ALLOC(ndr, r->printer_name);
5465                 } else {
5466                         r->printer_name = NULL;
5467                 }
5468                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5469                 if (_ptr_server_name) {
5470                         NDR_PULL_ALLOC(ndr, r->server_name);
5471                 } else {
5472                         r->server_name = NULL;
5473                 }
5474                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5475                 if (_ptr_user_name) {
5476                         NDR_PULL_ALLOC(ndr, r->user_name);
5477                 } else {
5478                         r->user_name = NULL;
5479                 }
5480                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5481                 if (_ptr_document_name) {
5482                         NDR_PULL_ALLOC(ndr, r->document_name);
5483                 } else {
5484                         r->document_name = NULL;
5485                 }
5486                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5487                 if (_ptr_notify_name) {
5488                         NDR_PULL_ALLOC(ndr, r->notify_name);
5489                 } else {
5490                         r->notify_name = NULL;
5491                 }
5492                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5493                 if (_ptr_data_type) {
5494                         NDR_PULL_ALLOC(ndr, r->data_type);
5495                 } else {
5496                         r->data_type = NULL;
5497                 }
5498                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5499                 if (_ptr_print_processor) {
5500                         NDR_PULL_ALLOC(ndr, r->print_processor);
5501                 } else {
5502                         r->print_processor = NULL;
5503                 }
5504                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5505                 if (_ptr_parameters) {
5506                         NDR_PULL_ALLOC(ndr, r->parameters);
5507                 } else {
5508                         r->parameters = NULL;
5509                 }
5510                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5511                 if (_ptr_driver_name) {
5512                         NDR_PULL_ALLOC(ndr, r->driver_name);
5513                 } else {
5514                         r->driver_name = NULL;
5515                 }
5516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5517                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5518                 if (_ptr_text_status) {
5519                         NDR_PULL_ALLOC(ndr, r->text_status);
5520                 } else {
5521                         r->text_status = NULL;
5522                 }
5523                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5524                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5526                 if (r->priority > 99) {
5527                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5528                 }
5529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5531                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5534                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5537                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5538         }
5539         if (ndr_flags & NDR_BUFFERS) {
5540                 if (r->printer_name) {
5541                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5542                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5543                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5544                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5545                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_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->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5547                         }
5548                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5549                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5550                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5551                 }
5552                 if (r->server_name) {
5553                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5554                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5555                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5556                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5557                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5558                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5559                         }
5560                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5561                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5562                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5563                 }
5564                 if (r->user_name) {
5565                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5566                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5567                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5568                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5569                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5570                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
5571                         }
5572                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5573                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5574                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5575                 }
5576                 if (r->document_name) {
5577                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5578                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5579                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5580                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5581                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5582                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
5583                         }
5584                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5585                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5586                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5587                 }
5588                 if (r->notify_name) {
5589                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5590                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5591                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5592                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5593                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5594                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->notify_name), ndr_get_array_length(ndr, &r->notify_name));
5595                         }
5596                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5597                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5598                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5599                 }
5600                 if (r->data_type) {
5601                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5602                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5603                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5604                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5605                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5606                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
5607                         }
5608                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5609                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5610                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5611                 }
5612                 if (r->print_processor) {
5613                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5614                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5615                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5616                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5617                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5618                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
5619                         }
5620                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5621                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5622                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5623                 }
5624                 if (r->parameters) {
5625                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5626                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5627                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5628                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5629                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5630                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
5631                         }
5632                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5633                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5634                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5635                 }
5636                 if (r->driver_name) {
5637                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5638                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5639                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5640                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5641                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5642                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5643                         }
5644                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5645                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5646                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5647                 }
5648                 if (r->text_status) {
5649                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5650                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5651                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5652                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5653                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5654                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
5655                         }
5656                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5657                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5658                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5659                 }
5660         }
5661         return NDR_ERR_SUCCESS;
5662 }
5663
5664 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
5665 {
5666         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
5667         ndr->depth++;
5668         ndr_print_uint32(ndr, "job_id", r->job_id);
5669         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5670         ndr->depth++;
5671         if (r->printer_name) {
5672                 ndr_print_string(ndr, "printer_name", r->printer_name);
5673         }
5674         ndr->depth--;
5675         ndr_print_ptr(ndr, "server_name", r->server_name);
5676         ndr->depth++;
5677         if (r->server_name) {
5678                 ndr_print_string(ndr, "server_name", r->server_name);
5679         }
5680         ndr->depth--;
5681         ndr_print_ptr(ndr, "user_name", r->user_name);
5682         ndr->depth++;
5683         if (r->user_name) {
5684                 ndr_print_string(ndr, "user_name", r->user_name);
5685         }
5686         ndr->depth--;
5687         ndr_print_ptr(ndr, "document_name", r->document_name);
5688         ndr->depth++;
5689         if (r->document_name) {
5690                 ndr_print_string(ndr, "document_name", r->document_name);
5691         }
5692         ndr->depth--;
5693         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5694         ndr->depth++;
5695         if (r->notify_name) {
5696                 ndr_print_string(ndr, "notify_name", r->notify_name);
5697         }
5698         ndr->depth--;
5699         ndr_print_ptr(ndr, "data_type", r->data_type);
5700         ndr->depth++;
5701         if (r->data_type) {
5702                 ndr_print_string(ndr, "data_type", r->data_type);
5703         }
5704         ndr->depth--;
5705         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5706         ndr->depth++;
5707         if (r->print_processor) {
5708                 ndr_print_string(ndr, "print_processor", r->print_processor);
5709         }
5710         ndr->depth--;
5711         ndr_print_ptr(ndr, "parameters", r->parameters);
5712         ndr->depth++;
5713         if (r->parameters) {
5714                 ndr_print_string(ndr, "parameters", r->parameters);
5715         }
5716         ndr->depth--;
5717         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5718         ndr->depth++;
5719         if (r->driver_name) {
5720                 ndr_print_string(ndr, "driver_name", r->driver_name);
5721         }
5722         ndr->depth--;
5723         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5724         ndr_print_ptr(ndr, "text_status", r->text_status);
5725         ndr->depth++;
5726         if (r->text_status) {
5727                 ndr_print_string(ndr, "text_status", r->text_status);
5728         }
5729         ndr->depth--;
5730         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5731         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5732         ndr_print_uint32(ndr, "priority", r->priority);
5733         ndr_print_uint32(ndr, "position", r->position);
5734         ndr_print_uint32(ndr, "start_time", r->start_time);
5735         ndr_print_uint32(ndr, "until_time", r->until_time);
5736         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5737         ndr_print_uint32(ndr, "size", r->size);
5738         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5739         ndr_print_uint32(ndr, "time", r->time);
5740         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5741         ndr->depth--;
5742 }
5743
5744 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
5745 {
5746         if (ndr_flags & NDR_SCALARS) {
5747                 NDR_CHECK(ndr_push_align(ndr, 5));
5748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5749                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5750                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5751                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5752                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5753                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5754                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5755                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5756                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5757                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5759                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5761                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5767                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5768                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5772                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5773         }
5774         if (ndr_flags & NDR_BUFFERS) {
5775                 if (r->printer_name) {
5776                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5777                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5778                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5779                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5780                 }
5781                 if (r->server_name) {
5782                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5783                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5784                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5785                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5786                 }
5787                 if (r->user_name) {
5788                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5789                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5790                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5791                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5792                 }
5793                 if (r->document_name) {
5794                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5795                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5796                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5797                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5798                 }
5799                 if (r->notify_name) {
5800                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5801                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5802                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5803                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5804                 }
5805                 if (r->data_type) {
5806                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5807                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5808                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5809                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5810                 }
5811                 if (r->print_processor) {
5812                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5813                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5814                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5815                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5816                 }
5817                 if (r->parameters) {
5818                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5819                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5820                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5821                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5822                 }
5823                 if (r->driver_name) {
5824                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5825                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5826                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5827                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5828                 }
5829                 if (r->text_status) {
5830                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5831                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5832                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5833                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5834                 }
5835         }
5836         return NDR_ERR_SUCCESS;
5837 }
5838
5839 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5840 {
5841         uint32_t _ptr_printer_name;
5842         TALLOC_CTX *_mem_save_printer_name_0;
5843         uint32_t _ptr_server_name;
5844         TALLOC_CTX *_mem_save_server_name_0;
5845         uint32_t _ptr_user_name;
5846         TALLOC_CTX *_mem_save_user_name_0;
5847         uint32_t _ptr_document_name;
5848         TALLOC_CTX *_mem_save_document_name_0;
5849         uint32_t _ptr_notify_name;
5850         TALLOC_CTX *_mem_save_notify_name_0;
5851         uint32_t _ptr_data_type;
5852         TALLOC_CTX *_mem_save_data_type_0;
5853         uint32_t _ptr_print_processor;
5854         TALLOC_CTX *_mem_save_print_processor_0;
5855         uint32_t _ptr_parameters;
5856         TALLOC_CTX *_mem_save_parameters_0;
5857         uint32_t _ptr_driver_name;
5858         TALLOC_CTX *_mem_save_driver_name_0;
5859         uint32_t _ptr_text_status;
5860         TALLOC_CTX *_mem_save_text_status_0;
5861         if (ndr_flags & NDR_SCALARS) {
5862                 NDR_CHECK(ndr_pull_align(ndr, 5));
5863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5865                 if (_ptr_printer_name) {
5866                         NDR_PULL_ALLOC(ndr, r->printer_name);
5867                 } else {
5868                         r->printer_name = NULL;
5869                 }
5870                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5871                 if (_ptr_server_name) {
5872                         NDR_PULL_ALLOC(ndr, r->server_name);
5873                 } else {
5874                         r->server_name = NULL;
5875                 }
5876                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5877                 if (_ptr_user_name) {
5878                         NDR_PULL_ALLOC(ndr, r->user_name);
5879                 } else {
5880                         r->user_name = NULL;
5881                 }
5882                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5883                 if (_ptr_document_name) {
5884                         NDR_PULL_ALLOC(ndr, r->document_name);
5885                 } else {
5886                         r->document_name = NULL;
5887                 }
5888                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5889                 if (_ptr_notify_name) {
5890                         NDR_PULL_ALLOC(ndr, r->notify_name);
5891                 } else {
5892                         r->notify_name = NULL;
5893                 }
5894                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5895                 if (_ptr_data_type) {
5896                         NDR_PULL_ALLOC(ndr, r->data_type);
5897                 } else {
5898                         r->data_type = NULL;
5899                 }
5900                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5901                 if (_ptr_print_processor) {
5902                         NDR_PULL_ALLOC(ndr, r->print_processor);
5903                 } else {
5904                         r->print_processor = NULL;
5905                 }
5906                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5907                 if (_ptr_parameters) {
5908                         NDR_PULL_ALLOC(ndr, r->parameters);
5909                 } else {
5910                         r->parameters = NULL;
5911                 }
5912                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5913                 if (_ptr_driver_name) {
5914                         NDR_PULL_ALLOC(ndr, r->driver_name);
5915                 } else {
5916                         r->driver_name = NULL;
5917                 }
5918                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5919                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5920                 if (_ptr_text_status) {
5921                         NDR_PULL_ALLOC(ndr, r->text_status);
5922                 } else {
5923                         r->text_status = NULL;
5924                 }
5925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5926                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5928                 if (r->priority > 99) {
5929                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5930                 }
5931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5932                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5934                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5936                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5937                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5938                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5939                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5940                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5941         }
5942         if (ndr_flags & NDR_BUFFERS) {
5943                 if (r->printer_name) {
5944                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5945                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5946                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5947                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5948                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5949                                 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));
5950                         }
5951                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5952                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5953                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5954                 }
5955                 if (r->server_name) {
5956                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5957                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5958                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5959                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5960                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5961                                 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));
5962                         }
5963                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5964                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5965                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5966                 }
5967                 if (r->user_name) {
5968                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5969                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5970                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5971                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5972                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5973                                 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));
5974                         }
5975                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5976                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5977                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5978                 }
5979                 if (r->document_name) {
5980                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5981                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5982                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5983                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5984                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5985                                 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));
5986                         }
5987                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5988                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5989                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5990                 }
5991                 if (r->notify_name) {
5992                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5993                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5994                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5995                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5996                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5997                                 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));
5998                         }
5999                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
6000                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
6001                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
6002                 }
6003                 if (r->data_type) {
6004                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
6005                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
6006                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
6007                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
6008                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
6009                                 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));
6010                         }
6011                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
6012                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
6013                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
6014                 }
6015                 if (r->print_processor) {
6016                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6017                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
6018                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
6019                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
6020                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
6021                                 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));
6022                         }
6023                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
6024                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
6025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
6026                 }
6027                 if (r->parameters) {
6028                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6029                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6030                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6031                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6032                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6033                                 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));
6034                         }
6035                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6036                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6037                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6038                 }
6039                 if (r->driver_name) {
6040                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6041                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6042                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
6043                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
6044                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
6045                                 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));
6046                         }
6047                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
6048                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
6049                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6050                 }
6051                 if (r->text_status) {
6052                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
6053                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
6054                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
6055                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
6056                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
6057                                 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));
6058                         }
6059                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
6060                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
6061                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
6062                 }
6063         }
6064         return NDR_ERR_SUCCESS;
6065 }
6066
6067 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
6068 {
6069         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
6070         ndr->depth++;
6071         ndr_print_uint32(ndr, "job_id", r->job_id);
6072         ndr_print_ptr(ndr, "printer_name", r->printer_name);
6073         ndr->depth++;
6074         if (r->printer_name) {
6075                 ndr_print_string(ndr, "printer_name", r->printer_name);
6076         }
6077         ndr->depth--;
6078         ndr_print_ptr(ndr, "server_name", r->server_name);
6079         ndr->depth++;
6080         if (r->server_name) {
6081                 ndr_print_string(ndr, "server_name", r->server_name);
6082         }
6083         ndr->depth--;
6084         ndr_print_ptr(ndr, "user_name", r->user_name);
6085         ndr->depth++;
6086         if (r->user_name) {
6087                 ndr_print_string(ndr, "user_name", r->user_name);
6088         }
6089         ndr->depth--;
6090         ndr_print_ptr(ndr, "document_name", r->document_name);
6091         ndr->depth++;
6092         if (r->document_name) {
6093                 ndr_print_string(ndr, "document_name", r->document_name);
6094         }
6095         ndr->depth--;
6096         ndr_print_ptr(ndr, "notify_name", r->notify_name);
6097         ndr->depth++;
6098         if (r->notify_name) {
6099                 ndr_print_string(ndr, "notify_name", r->notify_name);
6100         }
6101         ndr->depth--;
6102         ndr_print_ptr(ndr, "data_type", r->data_type);
6103         ndr->depth++;
6104         if (r->data_type) {
6105                 ndr_print_string(ndr, "data_type", r->data_type);
6106         }
6107         ndr->depth--;
6108         ndr_print_ptr(ndr, "print_processor", r->print_processor);
6109         ndr->depth++;
6110         if (r->print_processor) {
6111                 ndr_print_string(ndr, "print_processor", r->print_processor);
6112         }
6113         ndr->depth--;
6114         ndr_print_ptr(ndr, "parameters", r->parameters);
6115         ndr->depth++;
6116         if (r->parameters) {
6117                 ndr_print_string(ndr, "parameters", r->parameters);
6118         }
6119         ndr->depth--;
6120         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6121         ndr->depth++;
6122         if (r->driver_name) {
6123                 ndr_print_string(ndr, "driver_name", r->driver_name);
6124         }
6125         ndr->depth--;
6126         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
6127         ndr_print_ptr(ndr, "text_status", r->text_status);
6128         ndr->depth++;
6129         if (r->text_status) {
6130                 ndr_print_string(ndr, "text_status", r->text_status);
6131         }
6132         ndr->depth--;
6133         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
6134         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
6135         ndr_print_uint32(ndr, "priority", r->priority);
6136         ndr_print_uint32(ndr, "position", r->position);
6137         ndr_print_uint32(ndr, "start_time", r->start_time);
6138         ndr_print_uint32(ndr, "until_time", r->until_time);
6139         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6140         ndr_print_uint32(ndr, "size", r->size);
6141         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
6142         ndr_print_uint32(ndr, "time", r->time);
6143         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
6144         ndr_print_uint32(ndr, "size_high", r->size_high);
6145         ndr->depth--;
6146 }
6147
6148 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
6149 {
6150         if (ndr_flags & NDR_SCALARS) {
6151                 int level = ndr_push_get_switch_value(ndr, r);
6152                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6153                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6154                 switch (level) {
6155                         case 1: {
6156                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6157                         break; }
6158
6159                         case 2: {
6160                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6161                         break; }
6162
6163                         case 3: {
6164                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6165                         break; }
6166
6167                         case 4: {
6168                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6169                         break; }
6170
6171                         default: {
6172                         break; }
6173
6174                 }
6175         }
6176         if (ndr_flags & NDR_BUFFERS) {
6177                 int level = ndr_push_get_switch_value(ndr, r);
6178                 switch (level) {
6179                         case 1:
6180                                 if (r->info1) {
6181                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6182                                 }
6183                         break;
6184
6185                         case 2:
6186                                 if (r->info2) {
6187                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6188                                 }
6189                         break;
6190
6191                         case 3:
6192                                 if (r->info3) {
6193                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6194                                 }
6195                         break;
6196
6197                         case 4:
6198                                 if (r->info4) {
6199                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6200                                 }
6201                         break;
6202
6203                         default:
6204                         break;
6205
6206                 }
6207         }
6208         return NDR_ERR_SUCCESS;
6209 }
6210
6211 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
6212 {
6213         int level;
6214         uint32_t _level;
6215         TALLOC_CTX *_mem_save_info1_0;
6216         TALLOC_CTX *_mem_save_info2_0;
6217         TALLOC_CTX *_mem_save_info3_0;
6218         TALLOC_CTX *_mem_save_info4_0;
6219         level = ndr_pull_get_switch_value(ndr, r);
6220         if (ndr_flags & NDR_SCALARS) {
6221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6222                 if (_level != level) {
6223                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6224                 }
6225                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6226                 switch (level) {
6227                         case 1: {
6228                                 uint32_t _ptr_info1;
6229                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6230                                 if (_ptr_info1) {
6231                                         NDR_PULL_ALLOC(ndr, r->info1);
6232                                 } else {
6233                                         r->info1 = NULL;
6234                                 }
6235                         break; }
6236
6237                         case 2: {
6238                                 uint32_t _ptr_info2;
6239                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6240                                 if (_ptr_info2) {
6241                                         NDR_PULL_ALLOC(ndr, r->info2);
6242                                 } else {
6243                                         r->info2 = NULL;
6244                                 }
6245                         break; }
6246
6247                         case 3: {
6248                                 uint32_t _ptr_info3;
6249                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6250                                 if (_ptr_info3) {
6251                                         NDR_PULL_ALLOC(ndr, r->info3);
6252                                 } else {
6253                                         r->info3 = NULL;
6254                                 }
6255                         break; }
6256
6257                         case 4: {
6258                                 uint32_t _ptr_info4;
6259                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6260                                 if (_ptr_info4) {
6261                                         NDR_PULL_ALLOC(ndr, r->info4);
6262                                 } else {
6263                                         r->info4 = NULL;
6264                                 }
6265                         break; }
6266
6267                         default: {
6268                         break; }
6269
6270                 }
6271         }
6272         if (ndr_flags & NDR_BUFFERS) {
6273                 switch (level) {
6274                         case 1:
6275                                 if (r->info1) {
6276                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6277                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6278                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6279                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6280                                 }
6281                         break;
6282
6283                         case 2:
6284                                 if (r->info2) {
6285                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6286                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
6287                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6288                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
6289                                 }
6290                         break;
6291
6292                         case 3:
6293                                 if (r->info3) {
6294                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
6295                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
6296                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6297                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
6298                                 }
6299                         break;
6300
6301                         case 4:
6302                                 if (r->info4) {
6303                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
6304                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
6305                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6306                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
6307                                 }
6308                         break;
6309
6310                         default:
6311                         break;
6312
6313                 }
6314         }
6315         return NDR_ERR_SUCCESS;
6316 }
6317
6318 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
6319 {
6320         int level;
6321         level = ndr_print_get_switch_value(ndr, r);
6322         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
6323         switch (level) {
6324                 case 1:
6325                         ndr_print_ptr(ndr, "info1", r->info1);
6326                         ndr->depth++;
6327                         if (r->info1) {
6328                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
6329                         }
6330                         ndr->depth--;
6331                 break;
6332
6333                 case 2:
6334                         ndr_print_ptr(ndr, "info2", r->info2);
6335                         ndr->depth++;
6336                         if (r->info2) {
6337                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
6338                         }
6339                         ndr->depth--;
6340                 break;
6341
6342                 case 3:
6343                         ndr_print_ptr(ndr, "info3", r->info3);
6344                         ndr->depth++;
6345                         if (r->info3) {
6346                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
6347                         }
6348                         ndr->depth--;
6349                 break;
6350
6351                 case 4:
6352                         ndr_print_ptr(ndr, "info4", r->info4);
6353                         ndr->depth++;
6354                         if (r->info4) {
6355                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
6356                         }
6357                         ndr->depth--;
6358                 break;
6359
6360                 default:
6361                 break;
6362
6363         }
6364 }
6365
6366 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
6367 {
6368         if (ndr_flags & NDR_SCALARS) {
6369                 NDR_CHECK(ndr_push_align(ndr, 5));
6370                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
6371                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
6372                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6373                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6374         }
6375         if (ndr_flags & NDR_BUFFERS) {
6376                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6377         }
6378         return NDR_ERR_SUCCESS;
6379 }
6380
6381 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
6382 {
6383         if (ndr_flags & NDR_SCALARS) {
6384                 NDR_CHECK(ndr_pull_align(ndr, 5));
6385                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
6386                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
6387                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6388                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6389         }
6390         if (ndr_flags & NDR_BUFFERS) {
6391                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6392         }
6393         return NDR_ERR_SUCCESS;
6394 }
6395
6396 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
6397 {
6398         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
6399         ndr->depth++;
6400         ndr_print_uint32(ndr, "level", r->level);
6401         ndr_print_set_switch_value(ndr, &r->info, r->level);
6402         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
6403         ndr->depth--;
6404 }
6405
6406 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
6407 {
6408         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6409         return NDR_ERR_SUCCESS;
6410 }
6411
6412 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
6413 {
6414         uint32_t v;
6415         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6416         *r = v;
6417         return NDR_ERR_SUCCESS;
6418 }
6419
6420 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
6421 {
6422         const char *val = NULL;
6423
6424         switch (r) {
6425                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
6426                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
6427                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
6428                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
6429                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
6430                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
6431                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
6432                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
6433                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
6434         }
6435         ndr_print_enum(ndr, name, "ENUM", val, r);
6436 }
6437
6438 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
6439 {
6440         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6441         return NDR_ERR_SUCCESS;
6442 }
6443
6444 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
6445 {
6446         uint32_t v;
6447         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6448         *r = v;
6449         return NDR_ERR_SUCCESS;
6450 }
6451
6452 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
6453 {
6454         const char *val = NULL;
6455
6456         switch (r) {
6457                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
6458                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
6459                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
6460                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
6461                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
6462         }
6463         ndr_print_enum(ndr, name, "ENUM", val, r);
6464 }
6465
6466 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
6467 {
6468         if (ndr_flags & NDR_SCALARS) {
6469                 NDR_CHECK(ndr_push_align(ndr, 5));
6470                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6471                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6472                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6473                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
6474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
6475                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
6477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
6478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
6479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
6480                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
6481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
6482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
6483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
6484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
6485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
6486                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
6487                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
6488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
6489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
6490                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
6491                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
6492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
6493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
6494                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
6495                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
6496                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
6497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
6498                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
6499                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6500         }
6501         if (ndr_flags & NDR_BUFFERS) {
6502                 if (r->servername) {
6503                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6504                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6505                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6506                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6507                 }
6508                 if (r->printername) {
6509                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6510                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6511                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6512                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6513                 }
6514         }
6515         return NDR_ERR_SUCCESS;
6516 }
6517
6518 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
6519 {
6520         uint32_t _ptr_servername;
6521         TALLOC_CTX *_mem_save_servername_0;
6522         uint32_t _ptr_printername;
6523         TALLOC_CTX *_mem_save_printername_0;
6524         if (ndr_flags & NDR_SCALARS) {
6525                 NDR_CHECK(ndr_pull_align(ndr, 5));
6526                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6527                 if (_ptr_servername) {
6528                         NDR_PULL_ALLOC(ndr, r->servername);
6529                 } else {
6530                         r->servername = NULL;
6531                 }
6532                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6533                 if (_ptr_printername) {
6534                         NDR_PULL_ALLOC(ndr, r->printername);
6535                 } else {
6536                         r->printername = NULL;
6537                 }
6538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
6540                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
6541                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
6543                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
6544                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
6545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
6546                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
6547                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
6548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
6549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
6550                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
6551                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
6552                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
6553                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
6554                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
6555                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
6556                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
6557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
6558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
6559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
6560                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
6561                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
6562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
6563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
6564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
6565                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6566         }
6567         if (ndr_flags & NDR_BUFFERS) {
6568                 if (r->servername) {
6569                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6570                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6571                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6572                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6573                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6574                                 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));
6575                         }
6576                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6577                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6578                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6579                 }
6580                 if (r->printername) {
6581                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6582                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6583                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6584                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6585                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6586                                 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));
6587                         }
6588                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6589                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6590                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6591                 }
6592         }
6593         return NDR_ERR_SUCCESS;
6594 }
6595
6596 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
6597 {
6598         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
6599         ndr->depth++;
6600         ndr_print_ptr(ndr, "servername", r->servername);
6601         ndr->depth++;
6602         if (r->servername) {
6603                 ndr_print_string(ndr, "servername", r->servername);
6604         }
6605         ndr->depth--;
6606         ndr_print_ptr(ndr, "printername", r->printername);
6607         ndr->depth++;
6608         if (r->printername) {
6609                 ndr_print_string(ndr, "printername", r->printername);
6610         }
6611         ndr->depth--;
6612         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6613         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
6614         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
6615         ndr_print_spoolss_Time(ndr, "time", &r->time);
6616         ndr_print_uint32(ndr, "global_counter", r->global_counter);
6617         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6618         ndr_print_uint32(ndr, "version", r->version);
6619         ndr_print_uint32(ndr, "free_build", r->free_build);
6620         ndr_print_uint32(ndr, "spooling", r->spooling);
6621         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
6622         ndr_print_uint32(ndr, "session_counter", r->session_counter);
6623         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
6624         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
6625         ndr_print_uint32(ndr, "job_error", r->job_error);
6626         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
6627         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
6628         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
6629         ndr_print_uint32(ndr, "change_id", r->change_id);
6630         ndr_print_WERROR(ndr, "last_error", r->last_error);
6631         ndr_print_uint32(ndr, "status", r->status);
6632         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
6633         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
6634         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
6635         ndr_print_uint16(ndr, "processor_level", r->processor_level);
6636         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
6637         ndr_print_uint32(ndr, "reserved2", r->reserved2);
6638         ndr_print_uint32(ndr, "reserved3", r->reserved3);
6639         ndr->depth--;
6640 }
6641
6642 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
6643 {
6644         if (ndr_flags & NDR_SCALARS) {
6645                 NDR_CHECK(ndr_push_align(ndr, 5));
6646                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
6647                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
6648                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
6649                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6650                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6651         }
6652         if (ndr_flags & NDR_BUFFERS) {
6653                 if (r->description) {
6654                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6655                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6656                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6657                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6658                 }
6659                 if (r->name) {
6660                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6661                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6662                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6663                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6664                 }
6665                 if (r->comment) {
6666                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6667                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6668                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6669                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6670                 }
6671         }
6672         return NDR_ERR_SUCCESS;
6673 }
6674
6675 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
6676 {
6677         uint32_t _ptr_description;
6678         TALLOC_CTX *_mem_save_description_0;
6679         uint32_t _ptr_name;
6680         TALLOC_CTX *_mem_save_name_0;
6681         uint32_t _ptr_comment;
6682         TALLOC_CTX *_mem_save_comment_0;
6683         if (ndr_flags & NDR_SCALARS) {
6684                 NDR_CHECK(ndr_pull_align(ndr, 5));
6685                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
6686                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
6687                 if (_ptr_description) {
6688                         NDR_PULL_ALLOC(ndr, r->description);
6689                 } else {
6690                         r->description = NULL;
6691                 }
6692                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
6693                 if (_ptr_name) {
6694                         NDR_PULL_ALLOC(ndr, r->name);
6695                 } else {
6696                         r->name = NULL;
6697                 }
6698                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6699                 if (_ptr_comment) {
6700                         NDR_PULL_ALLOC(ndr, r->comment);
6701                 } else {
6702                         r->comment = NULL;
6703                 }
6704                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6705         }
6706         if (ndr_flags & NDR_BUFFERS) {
6707                 if (r->description) {
6708                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
6709                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
6710                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
6711                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
6712                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
6713                                 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));
6714                         }
6715                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
6716                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
6717                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
6718                 }
6719                 if (r->name) {
6720                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6721                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
6722                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
6723                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
6724                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
6725                                 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));
6726                         }
6727                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
6728                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
6729                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6730                 }
6731                 if (r->comment) {
6732                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6733                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6734                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6735                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6736                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6737                                 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));
6738                         }
6739                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6740                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6741                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6742                 }
6743         }
6744         return NDR_ERR_SUCCESS;
6745 }
6746
6747 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
6748 {
6749         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
6750         ndr->depth++;
6751         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
6752         ndr_print_ptr(ndr, "description", r->description);
6753         ndr->depth++;
6754         if (r->description) {
6755                 ndr_print_string(ndr, "description", r->description);
6756         }
6757         ndr->depth--;
6758         ndr_print_ptr(ndr, "name", r->name);
6759         ndr->depth++;
6760         if (r->name) {
6761                 ndr_print_string(ndr, "name", r->name);
6762         }
6763         ndr->depth--;
6764         ndr_print_ptr(ndr, "comment", r->comment);
6765         ndr->depth++;
6766         if (r->comment) {
6767                 ndr_print_string(ndr, "comment", r->comment);
6768         }
6769         ndr->depth--;
6770         ndr->depth--;
6771 }
6772
6773 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
6774 {
6775         if (ndr_flags & NDR_SCALARS) {
6776                 NDR_CHECK(ndr_push_align(ndr, 5));
6777                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6778                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6779                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6780                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6781                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6782                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6783                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6784                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
6785                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6786                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6787                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6788                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
6790                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6791                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6795                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6797                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6798                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6799         }
6800         if (ndr_flags & NDR_BUFFERS) {
6801                 if (r->servername) {
6802                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6803                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6804                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6805                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6806                 }
6807                 if (r->printername) {
6808                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6809                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6810                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6811                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6812                 }
6813                 if (r->sharename) {
6814                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6815                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6816                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6817                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6818                 }
6819                 if (r->portname) {
6820                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6821                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6822                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6823                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6824                 }
6825                 if (r->drivername) {
6826                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6827                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6828                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6829                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6830                 }
6831                 if (r->comment) {
6832                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6833                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6834                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6835                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6836                 }
6837                 if (r->location) {
6838                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6839                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6840                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6841                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6842                 }
6843                 if (r->devmode) {
6844                         {
6845                                 struct ndr_push *_ndr_devmode;
6846                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6847                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6848                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
6849                         }
6850                 }
6851                 if (r->sepfile) {
6852                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6853                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6854                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6855                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6856                 }
6857                 if (r->printprocessor) {
6858                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6859                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6860                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6861                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6862                 }
6863                 if (r->datatype) {
6864                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6865                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6866                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6867                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6868                 }
6869                 if (r->parameters) {
6870                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6871                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6872                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6873                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6874                 }
6875                 if (r->secdesc) {
6876                         {
6877                                 struct ndr_push *_ndr_secdesc;
6878                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6879                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6880                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6881                         }
6882                 }
6883         }
6884         return NDR_ERR_SUCCESS;
6885 }
6886
6887 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6888 {
6889         uint32_t _ptr_servername;
6890         TALLOC_CTX *_mem_save_servername_0;
6891         uint32_t _ptr_printername;
6892         TALLOC_CTX *_mem_save_printername_0;
6893         uint32_t _ptr_sharename;
6894         TALLOC_CTX *_mem_save_sharename_0;
6895         uint32_t _ptr_portname;
6896         TALLOC_CTX *_mem_save_portname_0;
6897         uint32_t _ptr_drivername;
6898         TALLOC_CTX *_mem_save_drivername_0;
6899         uint32_t _ptr_comment;
6900         TALLOC_CTX *_mem_save_comment_0;
6901         uint32_t _ptr_location;
6902         TALLOC_CTX *_mem_save_location_0;
6903         uint32_t _ptr_devmode;
6904         TALLOC_CTX *_mem_save_devmode_0;
6905         uint32_t _ptr_sepfile;
6906         TALLOC_CTX *_mem_save_sepfile_0;
6907         uint32_t _ptr_printprocessor;
6908         TALLOC_CTX *_mem_save_printprocessor_0;
6909         uint32_t _ptr_datatype;
6910         TALLOC_CTX *_mem_save_datatype_0;
6911         uint32_t _ptr_parameters;
6912         TALLOC_CTX *_mem_save_parameters_0;
6913         uint32_t _ptr_secdesc;
6914         TALLOC_CTX *_mem_save_secdesc_0;
6915         if (ndr_flags & NDR_SCALARS) {
6916                 NDR_CHECK(ndr_pull_align(ndr, 5));
6917                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6918                 if (_ptr_servername) {
6919                         NDR_PULL_ALLOC(ndr, r->servername);
6920                 } else {
6921                         r->servername = NULL;
6922                 }
6923                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6924                 if (_ptr_printername) {
6925                         NDR_PULL_ALLOC(ndr, r->printername);
6926                 } else {
6927                         r->printername = NULL;
6928                 }
6929                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6930                 if (_ptr_sharename) {
6931                         NDR_PULL_ALLOC(ndr, r->sharename);
6932                 } else {
6933                         r->sharename = NULL;
6934                 }
6935                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6936                 if (_ptr_portname) {
6937                         NDR_PULL_ALLOC(ndr, r->portname);
6938                 } else {
6939                         r->portname = NULL;
6940                 }
6941                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6942                 if (_ptr_drivername) {
6943                         NDR_PULL_ALLOC(ndr, r->drivername);
6944                 } else {
6945                         r->drivername = NULL;
6946                 }
6947                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6948                 if (_ptr_comment) {
6949                         NDR_PULL_ALLOC(ndr, r->comment);
6950                 } else {
6951                         r->comment = NULL;
6952                 }
6953                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6954                 if (_ptr_location) {
6955                         NDR_PULL_ALLOC(ndr, r->location);
6956                 } else {
6957                         r->location = NULL;
6958                 }
6959                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
6960                 if (_ptr_devmode) {
6961                         NDR_PULL_ALLOC(ndr, r->devmode);
6962                 } else {
6963                         r->devmode = NULL;
6964                 }
6965                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6966                 if (_ptr_sepfile) {
6967                         NDR_PULL_ALLOC(ndr, r->sepfile);
6968                 } else {
6969                         r->sepfile = NULL;
6970                 }
6971                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6972                 if (_ptr_printprocessor) {
6973                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6974                 } else {
6975                         r->printprocessor = NULL;
6976                 }
6977                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6978                 if (_ptr_datatype) {
6979                         NDR_PULL_ALLOC(ndr, r->datatype);
6980                 } else {
6981                         r->datatype = NULL;
6982                 }
6983                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6984                 if (_ptr_parameters) {
6985                         NDR_PULL_ALLOC(ndr, r->parameters);
6986                 } else {
6987                         r->parameters = NULL;
6988                 }
6989                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
6990                 if (_ptr_secdesc) {
6991                         NDR_PULL_ALLOC(ndr, r->secdesc);
6992                 } else {
6993                         r->secdesc = NULL;
6994                 }
6995                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6996                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6997                 if (r->priority > 99) {
6998                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6999                 }
7000                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
7001                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
7002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
7003                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
7005                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
7006                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7007         }
7008         if (ndr_flags & NDR_BUFFERS) {
7009                 if (r->servername) {
7010                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7011                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7012                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7013                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7014                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7015                                 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));
7016                         }
7017                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7018                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7019                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7020                 }
7021                 if (r->printername) {
7022                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7023                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7024                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7025                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7026                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7027                                 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));
7028                         }
7029                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7030                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7031                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7032                 }
7033                 if (r->sharename) {
7034                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
7035                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
7036                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
7037                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
7038                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
7039                                 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));
7040                         }
7041                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
7042                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
7043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
7044                 }
7045                 if (r->portname) {
7046                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7047                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7048                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7049                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7050                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7051                                 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));
7052                         }
7053                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7054                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7056                 }
7057                 if (r->drivername) {
7058                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7059                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
7060                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
7061                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
7062                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
7063                                 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));
7064                         }
7065                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
7066                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
7067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
7068                 }
7069                 if (r->comment) {
7070                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
7071                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
7072                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
7073                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
7074                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
7075                                 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));
7076                         }
7077                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
7078                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
7079                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
7080                 }
7081                 if (r->location) {
7082                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
7083                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
7084                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
7085                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
7086                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
7087                                 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));
7088                         }
7089                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
7090                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
7091                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
7092                 }
7093                 if (r->devmode) {
7094                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
7095                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
7096                         {
7097                                 struct ndr_pull *_ndr_devmode;
7098                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
7099                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
7100                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
7101                         }
7102                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
7103                 }
7104                 if (r->sepfile) {
7105                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
7106                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
7107                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
7108                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
7109                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
7110                                 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));
7111                         }
7112                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
7113                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
7114                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
7115                 }
7116                 if (r->printprocessor) {
7117                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
7118                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
7119                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
7120                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
7121                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
7122                                 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));
7123                         }
7124                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
7125                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
7126                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
7127                 }
7128                 if (r->datatype) {
7129                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7130                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
7131                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
7132                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
7133                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
7134                                 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));
7135                         }
7136                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
7137                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
7138                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
7139                 }
7140                 if (r->parameters) {
7141                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
7142                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
7143                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
7144                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
7145                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
7146                                 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));
7147                         }
7148                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
7149                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
7150                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
7151                 }
7152                 if (r->secdesc) {
7153                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
7154                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
7155                         {
7156                                 struct ndr_pull *_ndr_secdesc;
7157                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
7158                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
7159                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
7160                         }
7161                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
7162                 }
7163         }
7164         return NDR_ERR_SUCCESS;
7165 }
7166
7167 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
7168 {
7169         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
7170         ndr->depth++;
7171         ndr_print_ptr(ndr, "servername", r->servername);
7172         ndr->depth++;
7173         if (r->servername) {
7174                 ndr_print_string(ndr, "servername", r->servername);
7175         }
7176         ndr->depth--;
7177         ndr_print_ptr(ndr, "printername", r->printername);
7178         ndr->depth++;
7179         if (r->printername) {
7180                 ndr_print_string(ndr, "printername", r->printername);
7181         }
7182         ndr->depth--;
7183         ndr_print_ptr(ndr, "sharename", r->sharename);
7184         ndr->depth++;
7185         if (r->sharename) {
7186                 ndr_print_string(ndr, "sharename", r->sharename);
7187         }
7188         ndr->depth--;
7189         ndr_print_ptr(ndr, "portname", r->portname);
7190         ndr->depth++;
7191         if (r->portname) {
7192                 ndr_print_string(ndr, "portname", r->portname);
7193         }
7194         ndr->depth--;
7195         ndr_print_ptr(ndr, "drivername", r->drivername);
7196         ndr->depth++;
7197         if (r->drivername) {
7198                 ndr_print_string(ndr, "drivername", r->drivername);
7199         }
7200         ndr->depth--;
7201         ndr_print_ptr(ndr, "comment", r->comment);
7202         ndr->depth++;
7203         if (r->comment) {
7204                 ndr_print_string(ndr, "comment", r->comment);
7205         }
7206         ndr->depth--;
7207         ndr_print_ptr(ndr, "location", r->location);
7208         ndr->depth++;
7209         if (r->location) {
7210                 ndr_print_string(ndr, "location", r->location);
7211         }
7212         ndr->depth--;
7213         ndr_print_ptr(ndr, "devmode", r->devmode);
7214         ndr->depth++;
7215         if (r->devmode) {
7216                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
7217         }
7218         ndr->depth--;
7219         ndr_print_ptr(ndr, "sepfile", r->sepfile);
7220         ndr->depth++;
7221         if (r->sepfile) {
7222                 ndr_print_string(ndr, "sepfile", r->sepfile);
7223         }
7224         ndr->depth--;
7225         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
7226         ndr->depth++;
7227         if (r->printprocessor) {
7228                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
7229         }
7230         ndr->depth--;
7231         ndr_print_ptr(ndr, "datatype", r->datatype);
7232         ndr->depth++;
7233         if (r->datatype) {
7234                 ndr_print_string(ndr, "datatype", r->datatype);
7235         }
7236         ndr->depth--;
7237         ndr_print_ptr(ndr, "parameters", r->parameters);
7238         ndr->depth++;
7239         if (r->parameters) {
7240                 ndr_print_string(ndr, "parameters", r->parameters);
7241         }
7242         ndr->depth--;
7243         ndr_print_ptr(ndr, "secdesc", r->secdesc);
7244         ndr->depth++;
7245         if (r->secdesc) {
7246                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
7247         }
7248         ndr->depth--;
7249         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7250         ndr_print_uint32(ndr, "priority", r->priority);
7251         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
7252         ndr_print_uint32(ndr, "starttime", r->starttime);
7253         ndr_print_uint32(ndr, "untiltime", r->untiltime);
7254         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7255         ndr_print_uint32(ndr, "cjobs", r->cjobs);
7256         ndr_print_uint32(ndr, "averageppm", r->averageppm);
7257         ndr->depth--;
7258 }
7259
7260 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
7261 {
7262         if (ndr_flags & NDR_SCALARS) {
7263                 NDR_CHECK(ndr_push_align(ndr, 4));
7264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
7265                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7266         }
7267         if (ndr_flags & NDR_BUFFERS) {
7268         }
7269         return NDR_ERR_SUCCESS;
7270 }
7271
7272 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
7273 {
7274         if (ndr_flags & NDR_SCALARS) {
7275                 NDR_CHECK(ndr_pull_align(ndr, 4));
7276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
7277                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7278         }
7279         if (ndr_flags & NDR_BUFFERS) {
7280         }
7281         return NDR_ERR_SUCCESS;
7282 }
7283
7284 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
7285 {
7286         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
7287         ndr->depth++;
7288         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
7289         ndr->depth--;
7290 }
7291
7292 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
7293 {
7294         if (ndr_flags & NDR_SCALARS) {
7295                 NDR_CHECK(ndr_push_align(ndr, 5));
7296                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7297                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
7298                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7299                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7300         }
7301         if (ndr_flags & NDR_BUFFERS) {
7302                 if (r->printername) {
7303                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7304                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7305                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7306                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7307                 }
7308                 if (r->servername) {
7309                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7310                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7311                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7312                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7313                 }
7314         }
7315         return NDR_ERR_SUCCESS;
7316 }
7317
7318 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
7319 {
7320         uint32_t _ptr_printername;
7321         TALLOC_CTX *_mem_save_printername_0;
7322         uint32_t _ptr_servername;
7323         TALLOC_CTX *_mem_save_servername_0;
7324         if (ndr_flags & NDR_SCALARS) {
7325                 NDR_CHECK(ndr_pull_align(ndr, 5));
7326                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7327                 if (_ptr_printername) {
7328                         NDR_PULL_ALLOC(ndr, r->printername);
7329                 } else {
7330                         r->printername = NULL;
7331                 }
7332                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
7333                 if (_ptr_servername) {
7334                         NDR_PULL_ALLOC(ndr, r->servername);
7335                 } else {
7336                         r->servername = NULL;
7337                 }
7338                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7339                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7340         }
7341         if (ndr_flags & NDR_BUFFERS) {
7342                 if (r->printername) {
7343                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7344                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7345                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7346                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7347                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7348                                 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));
7349                         }
7350                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7351                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7352                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7353                 }
7354                 if (r->servername) {
7355                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7356                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7357                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7358                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7359                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7360                                 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));
7361                         }
7362                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7363                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7364                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7365                 }
7366         }
7367         return NDR_ERR_SUCCESS;
7368 }
7369
7370 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
7371 {
7372         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
7373         ndr->depth++;
7374         ndr_print_ptr(ndr, "printername", r->printername);
7375         ndr->depth++;
7376         if (r->printername) {
7377                 ndr_print_string(ndr, "printername", r->printername);
7378         }
7379         ndr->depth--;
7380         ndr_print_ptr(ndr, "servername", r->servername);
7381         ndr->depth++;
7382         if (r->servername) {
7383                 ndr_print_string(ndr, "servername", r->servername);
7384         }
7385         ndr->depth--;
7386         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7387         ndr->depth--;
7388 }
7389
7390 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
7391 {
7392         if (ndr_flags & NDR_SCALARS) {
7393                 NDR_CHECK(ndr_push_align(ndr, 5));
7394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7395                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
7396                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
7398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
7399                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7400         }
7401         if (ndr_flags & NDR_BUFFERS) {
7402                 if (r->printername) {
7403                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7404                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7405                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7406                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7407                 }
7408                 if (r->portname) {
7409                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7410                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7411                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7412                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7413                 }
7414         }
7415         return NDR_ERR_SUCCESS;
7416 }
7417
7418 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
7419 {
7420         uint32_t _ptr_printername;
7421         TALLOC_CTX *_mem_save_printername_0;
7422         uint32_t _ptr_portname;
7423         TALLOC_CTX *_mem_save_portname_0;
7424         if (ndr_flags & NDR_SCALARS) {
7425                 NDR_CHECK(ndr_pull_align(ndr, 5));
7426                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7427                 if (_ptr_printername) {
7428                         NDR_PULL_ALLOC(ndr, r->printername);
7429                 } else {
7430                         r->printername = NULL;
7431                 }
7432                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
7433                 if (_ptr_portname) {
7434                         NDR_PULL_ALLOC(ndr, r->portname);
7435                 } else {
7436                         r->portname = NULL;
7437                 }
7438                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
7440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
7441                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7442         }
7443         if (ndr_flags & NDR_BUFFERS) {
7444                 if (r->printername) {
7445                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7446                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7447                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7448                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7449                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7450                                 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));
7451                         }
7452                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7453                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7454                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7455                 }
7456                 if (r->portname) {
7457                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7458                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7459                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7460                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7461                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7462                                 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));
7463                         }
7464                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7465                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7466                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7467                 }
7468         }
7469         return NDR_ERR_SUCCESS;
7470 }
7471
7472 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
7473 {
7474         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
7475         ndr->depth++;
7476         ndr_print_ptr(ndr, "printername", r->printername);
7477         ndr->depth++;
7478         if (r->printername) {
7479                 ndr_print_string(ndr, "printername", r->printername);
7480         }
7481         ndr->depth--;
7482         ndr_print_ptr(ndr, "portname", r->portname);
7483         ndr->depth++;
7484         if (r->portname) {
7485                 ndr_print_string(ndr, "portname", r->portname);
7486         }
7487         ndr->depth--;
7488         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7489         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
7490         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
7491         ndr->depth--;
7492 }
7493
7494 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
7495 {
7496         if (ndr_flags & NDR_SCALARS) {
7497                 NDR_CHECK(ndr_push_align(ndr, 4));
7498                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
7499                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7500         }
7501         if (ndr_flags & NDR_BUFFERS) {
7502         }
7503         return NDR_ERR_SUCCESS;
7504 }
7505
7506 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
7507 {
7508         if (ndr_flags & NDR_SCALARS) {
7509                 NDR_CHECK(ndr_pull_align(ndr, 4));
7510                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7511                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7512         }
7513         if (ndr_flags & NDR_BUFFERS) {
7514         }
7515         return NDR_ERR_SUCCESS;
7516 }
7517
7518 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
7519 {
7520         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
7521         ndr->depth++;
7522         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7523         ndr->depth--;
7524 }
7525
7526 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
7527 {
7528         if (ndr_flags & NDR_SCALARS) {
7529                 NDR_CHECK(ndr_push_align(ndr, 5));
7530                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
7531                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
7532                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7533         }
7534         if (ndr_flags & NDR_BUFFERS) {
7535                 if (r->guid) {
7536                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7537                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7538                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7539                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7540                 }
7541         }
7542         return NDR_ERR_SUCCESS;
7543 }
7544
7545 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
7546 {
7547         uint32_t _ptr_guid;
7548         TALLOC_CTX *_mem_save_guid_0;
7549         if (ndr_flags & NDR_SCALARS) {
7550                 NDR_CHECK(ndr_pull_align(ndr, 5));
7551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
7552                 if (_ptr_guid) {
7553                         NDR_PULL_ALLOC(ndr, r->guid);
7554                 } else {
7555                         r->guid = NULL;
7556                 }
7557                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
7558                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7559         }
7560         if (ndr_flags & NDR_BUFFERS) {
7561                 if (r->guid) {
7562                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7563                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
7564                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
7565                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
7566                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
7567                                 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));
7568                         }
7569                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
7570                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
7571                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
7572                 }
7573         }
7574         return NDR_ERR_SUCCESS;
7575 }
7576
7577 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
7578 {
7579         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
7580         ndr->depth++;
7581         ndr_print_ptr(ndr, "guid", r->guid);
7582         ndr->depth++;
7583         if (r->guid) {
7584                 ndr_print_string(ndr, "guid", r->guid);
7585         }
7586         ndr->depth--;
7587         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
7588         ndr->depth--;
7589 }
7590
7591 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
7592 {
7593         if (ndr_flags & NDR_SCALARS) {
7594                 int level = ndr_push_get_switch_value(ndr, r);
7595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
7596                 NDR_CHECK(ndr_push_union_align(ndr, 5));
7597                 switch (level) {
7598                         case 0: {
7599                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
7600                         break; }
7601
7602                         case 1: {
7603                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
7604                         break; }
7605
7606                         case 2: {
7607                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
7608                         break; }
7609
7610                         case 3: {
7611                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
7612                         break; }
7613
7614                         case 4: {
7615                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
7616                         break; }
7617
7618                         case 5: {
7619                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
7620                         break; }
7621
7622                         case 6: {
7623                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
7624                         break; }
7625
7626                         case 7: {
7627                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
7628                         break; }
7629
7630                         case 8: {
7631                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
7632                         break; }
7633
7634                         case 9: {
7635                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
7636                         break; }
7637
7638                         default: {
7639                         break; }
7640
7641                 }
7642         }
7643         if (ndr_flags & NDR_BUFFERS) {
7644                 int level = ndr_push_get_switch_value(ndr, r);
7645                 switch (level) {
7646                         case 0:
7647                                 if (r->info0) {
7648                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7649                                 }
7650                         break;
7651
7652                         case 1:
7653                                 if (r->info1) {
7654                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7655                                 }
7656                         break;
7657
7658                         case 2:
7659                                 if (r->info2) {
7660                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7661                                 }
7662                         break;
7663
7664                         case 3:
7665                                 if (r->info3) {
7666                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7667                                 }
7668                         break;
7669
7670                         case 4:
7671                                 if (r->info4) {
7672                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7673                                 }
7674                         break;
7675
7676                         case 5:
7677                                 if (r->info5) {
7678                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7679                                 }
7680                         break;
7681
7682                         case 6:
7683                                 if (r->info6) {
7684                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7685                                 }
7686                         break;
7687
7688                         case 7:
7689                                 if (r->info7) {
7690                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7691                                 }
7692                         break;
7693
7694                         case 8:
7695                                 if (r->info8) {
7696                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7697                                 }
7698                         break;
7699
7700                         case 9:
7701                                 if (r->info9) {
7702                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7703                                 }
7704                         break;
7705
7706                         default:
7707                         break;
7708
7709                 }
7710         }
7711         return NDR_ERR_SUCCESS;
7712 }
7713
7714 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
7715 {
7716         int level;
7717         uint32_t _level;
7718         TALLOC_CTX *_mem_save_info0_0;
7719         TALLOC_CTX *_mem_save_info1_0;
7720         TALLOC_CTX *_mem_save_info2_0;
7721         TALLOC_CTX *_mem_save_info3_0;
7722         TALLOC_CTX *_mem_save_info4_0;
7723         TALLOC_CTX *_mem_save_info5_0;
7724         TALLOC_CTX *_mem_save_info6_0;
7725         TALLOC_CTX *_mem_save_info7_0;
7726         TALLOC_CTX *_mem_save_info8_0;
7727         TALLOC_CTX *_mem_save_info9_0;
7728         level = ndr_pull_get_switch_value(ndr, r);
7729         if (ndr_flags & NDR_SCALARS) {
7730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7731                 if (_level != level) {
7732                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
7733                 }
7734                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
7735                 switch (level) {
7736                         case 0: {
7737                                 uint32_t _ptr_info0;
7738                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
7739                                 if (_ptr_info0) {
7740                                         NDR_PULL_ALLOC(ndr, r->info0);
7741                                 } else {
7742                                         r->info0 = NULL;
7743                                 }
7744                         break; }
7745
7746                         case 1: {
7747                                 uint32_t _ptr_info1;
7748                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
7749                                 if (_ptr_info1) {
7750                                         NDR_PULL_ALLOC(ndr, r->info1);
7751                                 } else {
7752                                         r->info1 = NULL;
7753                                 }
7754                         break; }
7755
7756                         case 2: {
7757                                 uint32_t _ptr_info2;
7758                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
7759                                 if (_ptr_info2) {
7760                                         NDR_PULL_ALLOC(ndr, r->info2);
7761                                 } else {
7762                                         r->info2 = NULL;
7763                                 }
7764                         break; }
7765
7766                         case 3: {
7767                                 uint32_t _ptr_info3;
7768                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7769                                 if (_ptr_info3) {
7770                                         NDR_PULL_ALLOC(ndr, r->info3);
7771                                 } else {
7772                                         r->info3 = NULL;
7773                                 }
7774                         break; }
7775
7776                         case 4: {
7777                                 uint32_t _ptr_info4;
7778                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7779                                 if (_ptr_info4) {
7780                                         NDR_PULL_ALLOC(ndr, r->info4);
7781                                 } else {
7782                                         r->info4 = NULL;
7783                                 }
7784                         break; }
7785
7786                         case 5: {
7787                                 uint32_t _ptr_info5;
7788                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7789                                 if (_ptr_info5) {
7790                                         NDR_PULL_ALLOC(ndr, r->info5);
7791                                 } else {
7792                                         r->info5 = NULL;
7793                                 }
7794                         break; }
7795
7796                         case 6: {
7797                                 uint32_t _ptr_info6;
7798                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7799                                 if (_ptr_info6) {
7800                                         NDR_PULL_ALLOC(ndr, r->info6);
7801                                 } else {
7802                                         r->info6 = NULL;
7803                                 }
7804                         break; }
7805
7806                         case 7: {
7807                                 uint32_t _ptr_info7;
7808                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7809                                 if (_ptr_info7) {
7810                                         NDR_PULL_ALLOC(ndr, r->info7);
7811                                 } else {
7812                                         r->info7 = NULL;
7813                                 }
7814                         break; }
7815
7816                         case 8: {
7817                                 uint32_t _ptr_info8;
7818                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7819                                 if (_ptr_info8) {
7820                                         NDR_PULL_ALLOC(ndr, r->info8);
7821                                 } else {
7822                                         r->info8 = NULL;
7823                                 }
7824                         break; }
7825
7826                         case 9: {
7827                                 uint32_t _ptr_info9;
7828                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7829                                 if (_ptr_info9) {
7830                                         NDR_PULL_ALLOC(ndr, r->info9);
7831                                 } else {
7832                                         r->info9 = NULL;
7833                                 }
7834                         break; }
7835
7836                         default: {
7837                         break; }
7838
7839                 }
7840         }
7841         if (ndr_flags & NDR_BUFFERS) {
7842                 switch (level) {
7843                         case 0:
7844                                 if (r->info0) {
7845                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7846                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7847                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7848                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7849                                 }
7850                         break;
7851
7852                         case 1:
7853                                 if (r->info1) {
7854                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7855                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7856                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7857                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7858                                 }
7859                         break;
7860
7861                         case 2:
7862                                 if (r->info2) {
7863                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7864                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7865                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7866                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7867                                 }
7868                         break;
7869
7870                         case 3:
7871                                 if (r->info3) {
7872                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7873                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7874                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7875                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7876                                 }
7877                         break;
7878
7879                         case 4:
7880                                 if (r->info4) {
7881                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7882                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7883                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7884                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7885                                 }
7886                         break;
7887
7888                         case 5:
7889                                 if (r->info5) {
7890                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7891                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7892                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7893                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7894                                 }
7895                         break;
7896
7897                         case 6:
7898                                 if (r->info6) {
7899                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7900                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7901                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7902                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7903                                 }
7904                         break;
7905
7906                         case 7:
7907                                 if (r->info7) {
7908                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7909                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7910                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7911                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7912                                 }
7913                         break;
7914
7915                         case 8:
7916                                 if (r->info8) {
7917                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7918                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7919                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7920                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7921                                 }
7922                         break;
7923
7924                         case 9:
7925                                 if (r->info9) {
7926                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7927                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7928                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7929                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7930                                 }
7931                         break;
7932
7933                         default:
7934                         break;
7935
7936                 }
7937         }
7938         return NDR_ERR_SUCCESS;
7939 }
7940
7941 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7942 {
7943         int level;
7944         level = ndr_print_get_switch_value(ndr, r);
7945         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7946         switch (level) {
7947                 case 0:
7948                         ndr_print_ptr(ndr, "info0", r->info0);
7949                         ndr->depth++;
7950                         if (r->info0) {
7951                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
7952                         }
7953                         ndr->depth--;
7954                 break;
7955
7956                 case 1:
7957                         ndr_print_ptr(ndr, "info1", r->info1);
7958                         ndr->depth++;
7959                         if (r->info1) {
7960                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
7961                         }
7962                         ndr->depth--;
7963                 break;
7964
7965                 case 2:
7966                         ndr_print_ptr(ndr, "info2", r->info2);
7967                         ndr->depth++;
7968                         if (r->info2) {
7969                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
7970                         }
7971                         ndr->depth--;
7972                 break;
7973
7974                 case 3:
7975                         ndr_print_ptr(ndr, "info3", r->info3);
7976                         ndr->depth++;
7977                         if (r->info3) {
7978                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
7979                         }
7980                         ndr->depth--;
7981                 break;
7982
7983                 case 4:
7984                         ndr_print_ptr(ndr, "info4", r->info4);
7985                         ndr->depth++;
7986                         if (r->info4) {
7987                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
7988                         }
7989                         ndr->depth--;
7990                 break;
7991
7992                 case 5:
7993                         ndr_print_ptr(ndr, "info5", r->info5);
7994                         ndr->depth++;
7995                         if (r->info5) {
7996                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
7997                         }
7998                         ndr->depth--;
7999                 break;
8000
8001                 case 6:
8002                         ndr_print_ptr(ndr, "info6", r->info6);
8003                         ndr->depth++;
8004                         if (r->info6) {
8005                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
8006                         }
8007                         ndr->depth--;
8008                 break;
8009
8010                 case 7:
8011                         ndr_print_ptr(ndr, "info7", r->info7);
8012                         ndr->depth++;
8013                         if (r->info7) {
8014                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
8015                         }
8016                         ndr->depth--;
8017                 break;
8018
8019                 case 8:
8020                         ndr_print_ptr(ndr, "info8", r->info8);
8021                         ndr->depth++;
8022                         if (r->info8) {
8023                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
8024                         }
8025                         ndr->depth--;
8026                 break;
8027
8028                 case 9:
8029                         ndr_print_ptr(ndr, "info9", r->info9);
8030                         ndr->depth++;
8031                         if (r->info9) {
8032                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
8033                         }
8034                         ndr->depth--;
8035                 break;
8036
8037                 default:
8038                 break;
8039
8040         }
8041 }
8042
8043 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
8044 {
8045         if (ndr_flags & NDR_SCALARS) {
8046                 NDR_CHECK(ndr_push_align(ndr, 5));
8047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8048                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
8049                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8050                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8051         }
8052         if (ndr_flags & NDR_BUFFERS) {
8053                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8054         }
8055         return NDR_ERR_SUCCESS;
8056 }
8057
8058 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
8059 {
8060         if (ndr_flags & NDR_SCALARS) {
8061                 NDR_CHECK(ndr_pull_align(ndr, 5));
8062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8063                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
8064                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8065                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8066         }
8067         if (ndr_flags & NDR_BUFFERS) {
8068                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8069         }
8070         return NDR_ERR_SUCCESS;
8071 }
8072
8073 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
8074 {
8075         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
8076         ndr->depth++;
8077         ndr_print_uint32(ndr, "level", r->level);
8078         ndr_print_set_switch_value(ndr, &r->info, r->level);
8079         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
8080         ndr->depth--;
8081 }
8082
8083 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
8084 {
8085         if (ndr_flags & NDR_SCALARS) {
8086                 NDR_CHECK(ndr_push_align(ndr, 4));
8087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
8088                 {
8089                         uint32_t _flags_save_string_array = ndr->flags;
8090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8091                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
8092                         ndr->flags = _flags_save_string_array;
8093                 }
8094                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8095         }
8096         if (ndr_flags & NDR_BUFFERS) {
8097         }
8098         return NDR_ERR_SUCCESS;
8099 }
8100
8101 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
8102 {
8103         if (ndr_flags & NDR_SCALARS) {
8104                 NDR_CHECK(ndr_pull_align(ndr, 4));
8105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
8106                 {
8107                         uint32_t _flags_save_string_array = ndr->flags;
8108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8109                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
8110                         ndr->flags = _flags_save_string_array;
8111                 }
8112                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8113         }
8114         if (ndr_flags & NDR_BUFFERS) {
8115         }
8116         return NDR_ERR_SUCCESS;
8117 }
8118
8119 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
8120 {
8121         ndr_print_struct(ndr, name, "spoolss_StringArray");
8122         ndr->depth++;
8123         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);
8124         ndr_print_string_array(ndr, "string", r->string);
8125         ndr->depth--;
8126 }
8127
8128 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
8129 {
8130         if (ndr_flags & NDR_SCALARS) {
8131                 NDR_CHECK(ndr_push_align(ndr, 5));
8132                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8133                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8134         }
8135         if (ndr_flags & NDR_BUFFERS) {
8136                 if (r->driver_name) {
8137                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8139                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8140                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8141                 }
8142         }
8143         return NDR_ERR_SUCCESS;
8144 }
8145
8146 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
8147 {
8148         uint32_t _ptr_driver_name;
8149         TALLOC_CTX *_mem_save_driver_name_0;
8150         if (ndr_flags & NDR_SCALARS) {
8151                 NDR_CHECK(ndr_pull_align(ndr, 5));
8152                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8153                 if (_ptr_driver_name) {
8154                         NDR_PULL_ALLOC(ndr, r->driver_name);
8155                 } else {
8156                         r->driver_name = NULL;
8157                 }
8158                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8159         }
8160         if (ndr_flags & NDR_BUFFERS) {
8161                 if (r->driver_name) {
8162                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8163                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8164                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8165                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8166                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8167                                 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));
8168                         }
8169                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8170                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8172                 }
8173         }
8174         return NDR_ERR_SUCCESS;
8175 }
8176
8177 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
8178 {
8179         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
8180         ndr->depth++;
8181         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8182         ndr->depth++;
8183         if (r->driver_name) {
8184                 ndr_print_string(ndr, "driver_name", r->driver_name);
8185         }
8186         ndr->depth--;
8187         ndr->depth--;
8188 }
8189
8190 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
8191 {
8192         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
8193         return NDR_ERR_SUCCESS;
8194 }
8195
8196 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
8197 {
8198         uint32_t v;
8199         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
8200         *r = v;
8201         return NDR_ERR_SUCCESS;
8202 }
8203
8204 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
8205 {
8206         const char *val = NULL;
8207
8208         switch (r) {
8209                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
8210                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
8211                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
8212                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
8213         }
8214         ndr_print_enum(ndr, name, "ENUM", val, r);
8215 }
8216
8217 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
8218 {
8219         if (ndr_flags & NDR_SCALARS) {
8220                 NDR_CHECK(ndr_push_align(ndr, 5));
8221                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8222                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8223                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8224                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8225                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8226                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8227                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8228         }
8229         if (ndr_flags & NDR_BUFFERS) {
8230                 if (r->driver_name) {
8231                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8232                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8233                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8234                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8235                 }
8236                 if (r->architecture) {
8237                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8238                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8239                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8240                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8241                 }
8242                 if (r->driver_path) {
8243                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8244                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8245                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8246                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8247                 }
8248                 if (r->data_file) {
8249                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8250                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8251                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8252                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8253                 }
8254                 if (r->config_file) {
8255                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8256                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8257                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8258                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8259                 }
8260         }
8261         return NDR_ERR_SUCCESS;
8262 }
8263
8264 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
8265 {
8266         uint32_t _ptr_driver_name;
8267         TALLOC_CTX *_mem_save_driver_name_0;
8268         uint32_t _ptr_architecture;
8269         TALLOC_CTX *_mem_save_architecture_0;
8270         uint32_t _ptr_driver_path;
8271         TALLOC_CTX *_mem_save_driver_path_0;
8272         uint32_t _ptr_data_file;
8273         TALLOC_CTX *_mem_save_data_file_0;
8274         uint32_t _ptr_config_file;
8275         TALLOC_CTX *_mem_save_config_file_0;
8276         if (ndr_flags & NDR_SCALARS) {
8277                 NDR_CHECK(ndr_pull_align(ndr, 5));
8278                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8279                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8280                 if (_ptr_driver_name) {
8281                         NDR_PULL_ALLOC(ndr, r->driver_name);
8282                 } else {
8283                         r->driver_name = NULL;
8284                 }
8285                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8286                 if (_ptr_architecture) {
8287                         NDR_PULL_ALLOC(ndr, r->architecture);
8288                 } else {
8289                         r->architecture = NULL;
8290                 }
8291                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8292                 if (_ptr_driver_path) {
8293                         NDR_PULL_ALLOC(ndr, r->driver_path);
8294                 } else {
8295                         r->driver_path = NULL;
8296                 }
8297                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8298                 if (_ptr_data_file) {
8299                         NDR_PULL_ALLOC(ndr, r->data_file);
8300                 } else {
8301                         r->data_file = NULL;
8302                 }
8303                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8304                 if (_ptr_config_file) {
8305                         NDR_PULL_ALLOC(ndr, r->config_file);
8306                 } else {
8307                         r->config_file = NULL;
8308                 }
8309                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8310         }
8311         if (ndr_flags & NDR_BUFFERS) {
8312                 if (r->driver_name) {
8313                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8314                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8315                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8316                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8317                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8318                                 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));
8319                         }
8320                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8321                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8322                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8323                 }
8324                 if (r->architecture) {
8325                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8326                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8327                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8328                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8329                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8330                                 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));
8331                         }
8332                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8333                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8334                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8335                 }
8336                 if (r->driver_path) {
8337                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8338                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8339                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8340                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8341                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8342                                 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));
8343                         }
8344                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8345                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8346                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8347                 }
8348                 if (r->data_file) {
8349                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8350                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8351                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8352                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8353                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8354                                 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));
8355                         }
8356                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8357                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8358                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8359                 }
8360                 if (r->config_file) {
8361                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8362                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8363                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8364                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8365                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8366                                 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));
8367                         }
8368                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8369                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8370                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8371                 }
8372         }
8373         return NDR_ERR_SUCCESS;
8374 }
8375
8376 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
8377 {
8378         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
8379         ndr->depth++;
8380         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8381         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8382         ndr->depth++;
8383         if (r->driver_name) {
8384                 ndr_print_string(ndr, "driver_name", r->driver_name);
8385         }
8386         ndr->depth--;
8387         ndr_print_ptr(ndr, "architecture", r->architecture);
8388         ndr->depth++;
8389         if (r->architecture) {
8390                 ndr_print_string(ndr, "architecture", r->architecture);
8391         }
8392         ndr->depth--;
8393         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8394         ndr->depth++;
8395         if (r->driver_path) {
8396                 ndr_print_string(ndr, "driver_path", r->driver_path);
8397         }
8398         ndr->depth--;
8399         ndr_print_ptr(ndr, "data_file", r->data_file);
8400         ndr->depth++;
8401         if (r->data_file) {
8402                 ndr_print_string(ndr, "data_file", r->data_file);
8403         }
8404         ndr->depth--;
8405         ndr_print_ptr(ndr, "config_file", r->config_file);
8406         ndr->depth++;
8407         if (r->config_file) {
8408                 ndr_print_string(ndr, "config_file", r->config_file);
8409         }
8410         ndr->depth--;
8411         ndr->depth--;
8412 }
8413
8414 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
8415 {
8416         if (ndr_flags & NDR_SCALARS) {
8417                 NDR_CHECK(ndr_push_align(ndr, 5));
8418                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8419                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8420                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8421                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8422                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8423                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8424                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8425                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8426                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8427                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8428                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8429                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8430         }
8431         if (ndr_flags & NDR_BUFFERS) {
8432                 if (r->driver_name) {
8433                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8434                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8435                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8436                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8437                 }
8438                 if (r->architecture) {
8439                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8440                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8441                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8442                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8443                 }
8444                 if (r->driver_path) {
8445                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8446                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8447                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8448                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8449                 }
8450                 if (r->data_file) {
8451                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8452                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8453                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8454                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8455                 }
8456                 if (r->config_file) {
8457                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8458                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8459                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8460                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8461                 }
8462                 if (r->help_file) {
8463                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8464                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8465                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8466                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8467                 }
8468                 if (r->monitor_name) {
8469                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8470                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8471                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8472                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8473                 }
8474                 if (r->default_datatype) {
8475                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8476                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8477                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8478                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8479                 }
8480                 if (r->dependent_files) {
8481                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8482                 }
8483         }
8484         return NDR_ERR_SUCCESS;
8485 }
8486
8487 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
8488 {
8489         uint32_t _ptr_driver_name;
8490         TALLOC_CTX *_mem_save_driver_name_0;
8491         uint32_t _ptr_architecture;
8492         TALLOC_CTX *_mem_save_architecture_0;
8493         uint32_t _ptr_driver_path;
8494         TALLOC_CTX *_mem_save_driver_path_0;
8495         uint32_t _ptr_data_file;
8496         TALLOC_CTX *_mem_save_data_file_0;
8497         uint32_t _ptr_config_file;
8498         TALLOC_CTX *_mem_save_config_file_0;
8499         uint32_t _ptr_help_file;
8500         TALLOC_CTX *_mem_save_help_file_0;
8501         uint32_t _ptr_monitor_name;
8502         TALLOC_CTX *_mem_save_monitor_name_0;
8503         uint32_t _ptr_default_datatype;
8504         TALLOC_CTX *_mem_save_default_datatype_0;
8505         uint32_t _ptr_dependent_files;
8506         TALLOC_CTX *_mem_save_dependent_files_0;
8507         if (ndr_flags & NDR_SCALARS) {
8508                 NDR_CHECK(ndr_pull_align(ndr, 5));
8509                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8510                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8511                 if (_ptr_driver_name) {
8512                         NDR_PULL_ALLOC(ndr, r->driver_name);
8513                 } else {
8514                         r->driver_name = NULL;
8515                 }
8516                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8517                 if (_ptr_architecture) {
8518                         NDR_PULL_ALLOC(ndr, r->architecture);
8519                 } else {
8520                         r->architecture = NULL;
8521                 }
8522                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8523                 if (_ptr_driver_path) {
8524                         NDR_PULL_ALLOC(ndr, r->driver_path);
8525                 } else {
8526                         r->driver_path = NULL;
8527                 }
8528                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8529                 if (_ptr_data_file) {
8530                         NDR_PULL_ALLOC(ndr, r->data_file);
8531                 } else {
8532                         r->data_file = NULL;
8533                 }
8534                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8535                 if (_ptr_config_file) {
8536                         NDR_PULL_ALLOC(ndr, r->config_file);
8537                 } else {
8538                         r->config_file = NULL;
8539                 }
8540                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8541                 if (_ptr_help_file) {
8542                         NDR_PULL_ALLOC(ndr, r->help_file);
8543                 } else {
8544                         r->help_file = NULL;
8545                 }
8546                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8547                 if (_ptr_monitor_name) {
8548                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8549                 } else {
8550                         r->monitor_name = NULL;
8551                 }
8552                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8553                 if (_ptr_default_datatype) {
8554                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8555                 } else {
8556                         r->default_datatype = NULL;
8557                 }
8558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8559                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8560                 if (_ptr_dependent_files) {
8561                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8562                 } else {
8563                         r->dependent_files = NULL;
8564                 }
8565                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8566         }
8567         if (ndr_flags & NDR_BUFFERS) {
8568                 if (r->driver_name) {
8569                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8570                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8571                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8572                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8573                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8574                                 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));
8575                         }
8576                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8577                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8578                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8579                 }
8580                 if (r->architecture) {
8581                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8582                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8583                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8584                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8585                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8586                                 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));
8587                         }
8588                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8589                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8590                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8591                 }
8592                 if (r->driver_path) {
8593                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8594                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8595                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8596                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8597                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8598                                 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));
8599                         }
8600                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8601                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8602                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8603                 }
8604                 if (r->data_file) {
8605                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8606                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8607                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8608                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8609                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8610                                 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));
8611                         }
8612                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8613                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8615                 }
8616                 if (r->config_file) {
8617                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8618                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8619                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8620                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8621                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8622                                 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));
8623                         }
8624                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8625                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8626                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8627                 }
8628                 if (r->help_file) {
8629                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8630                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8631                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8632                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8633                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8634                                 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));
8635                         }
8636                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8637                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8638                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8639                 }
8640                 if (r->monitor_name) {
8641                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8642                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8643                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8644                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8645                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8646                                 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));
8647                         }
8648                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8649                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8650                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8651                 }
8652                 if (r->default_datatype) {
8653                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8654                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8655                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8656                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8657                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8658                                 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));
8659                         }
8660                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8661                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8662                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8663                 }
8664                 if (r->dependent_files) {
8665                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8666                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8667                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8668                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8669                 }
8670         }
8671         return NDR_ERR_SUCCESS;
8672 }
8673
8674 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
8675 {
8676         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
8677         ndr->depth++;
8678         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8679         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8680         ndr->depth++;
8681         if (r->driver_name) {
8682                 ndr_print_string(ndr, "driver_name", r->driver_name);
8683         }
8684         ndr->depth--;
8685         ndr_print_ptr(ndr, "architecture", r->architecture);
8686         ndr->depth++;
8687         if (r->architecture) {
8688                 ndr_print_string(ndr, "architecture", r->architecture);
8689         }
8690         ndr->depth--;
8691         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8692         ndr->depth++;
8693         if (r->driver_path) {
8694                 ndr_print_string(ndr, "driver_path", r->driver_path);
8695         }
8696         ndr->depth--;
8697         ndr_print_ptr(ndr, "data_file", r->data_file);
8698         ndr->depth++;
8699         if (r->data_file) {
8700                 ndr_print_string(ndr, "data_file", r->data_file);
8701         }
8702         ndr->depth--;
8703         ndr_print_ptr(ndr, "config_file", r->config_file);
8704         ndr->depth++;
8705         if (r->config_file) {
8706                 ndr_print_string(ndr, "config_file", r->config_file);
8707         }
8708         ndr->depth--;
8709         ndr_print_ptr(ndr, "help_file", r->help_file);
8710         ndr->depth++;
8711         if (r->help_file) {
8712                 ndr_print_string(ndr, "help_file", r->help_file);
8713         }
8714         ndr->depth--;
8715         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8716         ndr->depth++;
8717         if (r->monitor_name) {
8718                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8719         }
8720         ndr->depth--;
8721         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8722         ndr->depth++;
8723         if (r->default_datatype) {
8724                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8725         }
8726         ndr->depth--;
8727         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);
8728         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8729         ndr->depth++;
8730         if (r->dependent_files) {
8731                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8732         }
8733         ndr->depth--;
8734         ndr->depth--;
8735 }
8736
8737 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
8738 {
8739         if (ndr_flags & NDR_SCALARS) {
8740                 NDR_CHECK(ndr_push_align(ndr, 5));
8741                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8742                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8743                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8744                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8745                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8746                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8747                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8748                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8749                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8751                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8752                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8753                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8754                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8755         }
8756         if (ndr_flags & NDR_BUFFERS) {
8757                 if (r->driver_name) {
8758                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_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->driver_name, CH_UTF16)));
8761                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8762                 }
8763                 if (r->architecture) {
8764                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, 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->architecture, CH_UTF16)));
8767                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8768                 }
8769                 if (r->driver_path) {
8770                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8771                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8772                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8773                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8774                 }
8775                 if (r->data_file) {
8776                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8777                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8778                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8779                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8780                 }
8781                 if (r->config_file) {
8782                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8783                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8784                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8785                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8786                 }
8787                 if (r->help_file) {
8788                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8789                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8790                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8791                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8792                 }
8793                 if (r->monitor_name) {
8794                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8795                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8796                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8797                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8798                 }
8799                 if (r->default_datatype) {
8800                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8801                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8802                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8803                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8804                 }
8805                 if (r->dependent_files) {
8806                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8807                 }
8808                 if (r->previous_names) {
8809                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8810                 }
8811         }
8812         return NDR_ERR_SUCCESS;
8813 }
8814
8815 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8816 {
8817         uint32_t _ptr_driver_name;
8818         TALLOC_CTX *_mem_save_driver_name_0;
8819         uint32_t _ptr_architecture;
8820         TALLOC_CTX *_mem_save_architecture_0;
8821         uint32_t _ptr_driver_path;
8822         TALLOC_CTX *_mem_save_driver_path_0;
8823         uint32_t _ptr_data_file;
8824         TALLOC_CTX *_mem_save_data_file_0;
8825         uint32_t _ptr_config_file;
8826         TALLOC_CTX *_mem_save_config_file_0;
8827         uint32_t _ptr_help_file;
8828         TALLOC_CTX *_mem_save_help_file_0;
8829         uint32_t _ptr_monitor_name;
8830         TALLOC_CTX *_mem_save_monitor_name_0;
8831         uint32_t _ptr_default_datatype;
8832         TALLOC_CTX *_mem_save_default_datatype_0;
8833         uint32_t _ptr_dependent_files;
8834         TALLOC_CTX *_mem_save_dependent_files_0;
8835         uint32_t _ptr_previous_names;
8836         TALLOC_CTX *_mem_save_previous_names_0;
8837         if (ndr_flags & NDR_SCALARS) {
8838                 NDR_CHECK(ndr_pull_align(ndr, 5));
8839                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8840                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8841                 if (_ptr_driver_name) {
8842                         NDR_PULL_ALLOC(ndr, r->driver_name);
8843                 } else {
8844                         r->driver_name = NULL;
8845                 }
8846                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8847                 if (_ptr_architecture) {
8848                         NDR_PULL_ALLOC(ndr, r->architecture);
8849                 } else {
8850                         r->architecture = NULL;
8851                 }
8852                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8853                 if (_ptr_driver_path) {
8854                         NDR_PULL_ALLOC(ndr, r->driver_path);
8855                 } else {
8856                         r->driver_path = NULL;
8857                 }
8858                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8859                 if (_ptr_data_file) {
8860                         NDR_PULL_ALLOC(ndr, r->data_file);
8861                 } else {
8862                         r->data_file = NULL;
8863                 }
8864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8865                 if (_ptr_config_file) {
8866                         NDR_PULL_ALLOC(ndr, r->config_file);
8867                 } else {
8868                         r->config_file = NULL;
8869                 }
8870                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8871                 if (_ptr_help_file) {
8872                         NDR_PULL_ALLOC(ndr, r->help_file);
8873                 } else {
8874                         r->help_file = NULL;
8875                 }
8876                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8877                 if (_ptr_monitor_name) {
8878                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8879                 } else {
8880                         r->monitor_name = NULL;
8881                 }
8882                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8883                 if (_ptr_default_datatype) {
8884                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8885                 } else {
8886                         r->default_datatype = NULL;
8887                 }
8888                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8889                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8890                 if (_ptr_dependent_files) {
8891                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8892                 } else {
8893                         r->dependent_files = NULL;
8894                 }
8895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8896                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8897                 if (_ptr_previous_names) {
8898                         NDR_PULL_ALLOC(ndr, r->previous_names);
8899                 } else {
8900                         r->previous_names = NULL;
8901                 }
8902                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8903         }
8904         if (ndr_flags & NDR_BUFFERS) {
8905                 if (r->driver_name) {
8906                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8907                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8908                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8909                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8910                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
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->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8912                         }
8913                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8914                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8915                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8916                 }
8917                 if (r->architecture) {
8918                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8919                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8920                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8921                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8922                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
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->architecture), ndr_get_array_length(ndr, &r->architecture));
8924                         }
8925                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8926                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8927                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8928                 }
8929                 if (r->driver_path) {
8930                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8931                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8932                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8933                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8934                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
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->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8936                         }
8937                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8938                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8939                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8940                 }
8941                 if (r->data_file) {
8942                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8943                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8944                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8945                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8946                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
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->data_file), ndr_get_array_length(ndr, &r->data_file));
8948                         }
8949                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8950                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8951                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8952                 }
8953                 if (r->config_file) {
8954                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8955                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8956                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8957                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8958                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8959                                 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));
8960                         }
8961                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8962                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8963                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8964                 }
8965                 if (r->help_file) {
8966                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8967                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8968                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8969                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8970                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8971                                 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));
8972                         }
8973                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8974                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8975                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8976                 }
8977                 if (r->monitor_name) {
8978                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8979                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8980                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8981                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8982                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8983                                 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));
8984                         }
8985                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8986                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8987                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8988                 }
8989                 if (r->default_datatype) {
8990                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8991                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8992                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8993                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8994                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8995                                 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));
8996                         }
8997                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8998                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8999                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9000                 }
9001                 if (r->dependent_files) {
9002                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9003                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9004                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9005                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9006                 }
9007                 if (r->previous_names) {
9008                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9009                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9010                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9011                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9012                 }
9013         }
9014         return NDR_ERR_SUCCESS;
9015 }
9016
9017 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
9018 {
9019         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
9020         ndr->depth++;
9021         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9022         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9023         ndr->depth++;
9024         if (r->driver_name) {
9025                 ndr_print_string(ndr, "driver_name", r->driver_name);
9026         }
9027         ndr->depth--;
9028         ndr_print_ptr(ndr, "architecture", r->architecture);
9029         ndr->depth++;
9030         if (r->architecture) {
9031                 ndr_print_string(ndr, "architecture", r->architecture);
9032         }
9033         ndr->depth--;
9034         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9035         ndr->depth++;
9036         if (r->driver_path) {
9037                 ndr_print_string(ndr, "driver_path", r->driver_path);
9038         }
9039         ndr->depth--;
9040         ndr_print_ptr(ndr, "data_file", r->data_file);
9041         ndr->depth++;
9042         if (r->data_file) {
9043                 ndr_print_string(ndr, "data_file", r->data_file);
9044         }
9045         ndr->depth--;
9046         ndr_print_ptr(ndr, "config_file", r->config_file);
9047         ndr->depth++;
9048         if (r->config_file) {
9049                 ndr_print_string(ndr, "config_file", r->config_file);
9050         }
9051         ndr->depth--;
9052         ndr_print_ptr(ndr, "help_file", r->help_file);
9053         ndr->depth++;
9054         if (r->help_file) {
9055                 ndr_print_string(ndr, "help_file", r->help_file);
9056         }
9057         ndr->depth--;
9058         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9059         ndr->depth++;
9060         if (r->monitor_name) {
9061                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9062         }
9063         ndr->depth--;
9064         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9065         ndr->depth++;
9066         if (r->default_datatype) {
9067                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9068         }
9069         ndr->depth--;
9070         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);
9071         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9072         ndr->depth++;
9073         if (r->dependent_files) {
9074                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9075         }
9076         ndr->depth--;
9077         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);
9078         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9079         ndr->depth++;
9080         if (r->previous_names) {
9081                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9082         }
9083         ndr->depth--;
9084         ndr->depth--;
9085 }
9086
9087 static enum ndr_err_code ndr_push_spoolss_DriverAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9088 {
9089         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9090         return NDR_ERR_SUCCESS;
9091 }
9092
9093 static enum ndr_err_code ndr_pull_spoolss_DriverAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9094 {
9095         uint32_t v;
9096         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9097         *r = v;
9098         return NDR_ERR_SUCCESS;
9099 }
9100
9101 _PUBLIC_ void ndr_print_spoolss_DriverAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
9102 {
9103         ndr_print_uint32(ndr, name, r);
9104         ndr->depth++;
9105         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_DRIVER_PACKAGE_AWARE", PRINTER_DRIVER_PACKAGE_AWARE, r);
9106         ndr->depth--;
9107 }
9108
9109 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
9110 {
9111         if (ndr_flags & NDR_SCALARS) {
9112                 NDR_CHECK(ndr_push_align(ndr, 8));
9113                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9114                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9115                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9116                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9117                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9118                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9119                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9120                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9121                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9122                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9123                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9124                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9125                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9126                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9127                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9128                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9129                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9130                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9131                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9132                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9133         }
9134         if (ndr_flags & NDR_BUFFERS) {
9135                 if (r->driver_name) {
9136                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9137                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9139                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9140                 }
9141                 if (r->architecture) {
9142                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9143                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9144                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9145                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9146                 }
9147                 if (r->driver_path) {
9148                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9149                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9150                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9151                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9152                 }
9153                 if (r->data_file) {
9154                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9155                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9156                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9157                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9158                 }
9159                 if (r->config_file) {
9160                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9161                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9162                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9163                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9164                 }
9165                 if (r->help_file) {
9166                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9167                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9168                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9169                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9170                 }
9171                 if (r->monitor_name) {
9172                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9173                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9174                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9175                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9176                 }
9177                 if (r->default_datatype) {
9178                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9179                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9180                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9181                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9182                 }
9183                 if (r->dependent_files) {
9184                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9185                 }
9186                 if (r->previous_names) {
9187                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9188                 }
9189                 if (r->manufacturer_name) {
9190                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9191                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9192                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9193                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9194                 }
9195                 if (r->manufacturer_url) {
9196                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9197                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9198                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9199                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9200                 }
9201                 if (r->hardware_id) {
9202                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9203                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9204                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9205                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9206                 }
9207                 if (r->provider) {
9208                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9209                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9210                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9211                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9212                 }
9213         }
9214         return NDR_ERR_SUCCESS;
9215 }
9216
9217 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
9218 {
9219         uint32_t _ptr_driver_name;
9220         TALLOC_CTX *_mem_save_driver_name_0;
9221         uint32_t _ptr_architecture;
9222         TALLOC_CTX *_mem_save_architecture_0;
9223         uint32_t _ptr_driver_path;
9224         TALLOC_CTX *_mem_save_driver_path_0;
9225         uint32_t _ptr_data_file;
9226         TALLOC_CTX *_mem_save_data_file_0;
9227         uint32_t _ptr_config_file;
9228         TALLOC_CTX *_mem_save_config_file_0;
9229         uint32_t _ptr_help_file;
9230         TALLOC_CTX *_mem_save_help_file_0;
9231         uint32_t _ptr_monitor_name;
9232         TALLOC_CTX *_mem_save_monitor_name_0;
9233         uint32_t _ptr_default_datatype;
9234         TALLOC_CTX *_mem_save_default_datatype_0;
9235         uint32_t _ptr_dependent_files;
9236         TALLOC_CTX *_mem_save_dependent_files_0;
9237         uint32_t _ptr_previous_names;
9238         TALLOC_CTX *_mem_save_previous_names_0;
9239         uint32_t _ptr_manufacturer_name;
9240         TALLOC_CTX *_mem_save_manufacturer_name_0;
9241         uint32_t _ptr_manufacturer_url;
9242         TALLOC_CTX *_mem_save_manufacturer_url_0;
9243         uint32_t _ptr_hardware_id;
9244         TALLOC_CTX *_mem_save_hardware_id_0;
9245         uint32_t _ptr_provider;
9246         TALLOC_CTX *_mem_save_provider_0;
9247         if (ndr_flags & NDR_SCALARS) {
9248                 NDR_CHECK(ndr_pull_align(ndr, 8));
9249                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9250                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9251                 if (_ptr_driver_name) {
9252                         NDR_PULL_ALLOC(ndr, r->driver_name);
9253                 } else {
9254                         r->driver_name = NULL;
9255                 }
9256                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9257                 if (_ptr_architecture) {
9258                         NDR_PULL_ALLOC(ndr, r->architecture);
9259                 } else {
9260                         r->architecture = NULL;
9261                 }
9262                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9263                 if (_ptr_driver_path) {
9264                         NDR_PULL_ALLOC(ndr, r->driver_path);
9265                 } else {
9266                         r->driver_path = NULL;
9267                 }
9268                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9269                 if (_ptr_data_file) {
9270                         NDR_PULL_ALLOC(ndr, r->data_file);
9271                 } else {
9272                         r->data_file = NULL;
9273                 }
9274                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9275                 if (_ptr_config_file) {
9276                         NDR_PULL_ALLOC(ndr, r->config_file);
9277                 } else {
9278                         r->config_file = NULL;
9279                 }
9280                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9281                 if (_ptr_help_file) {
9282                         NDR_PULL_ALLOC(ndr, r->help_file);
9283                 } else {
9284                         r->help_file = NULL;
9285                 }
9286                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9287                 if (_ptr_monitor_name) {
9288                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9289                 } else {
9290                         r->monitor_name = NULL;
9291                 }
9292                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9293                 if (_ptr_default_datatype) {
9294                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9295                 } else {
9296                         r->default_datatype = NULL;
9297                 }
9298                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9299                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9300                 if (_ptr_dependent_files) {
9301                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9302                 } else {
9303                         r->dependent_files = NULL;
9304                 }
9305                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9306                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9307                 if (_ptr_previous_names) {
9308                         NDR_PULL_ALLOC(ndr, r->previous_names);
9309                 } else {
9310                         r->previous_names = NULL;
9311                 }
9312                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9313                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9314                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9315                 if (_ptr_manufacturer_name) {
9316                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9317                 } else {
9318                         r->manufacturer_name = NULL;
9319                 }
9320                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9321                 if (_ptr_manufacturer_url) {
9322                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9323                 } else {
9324                         r->manufacturer_url = NULL;
9325                 }
9326                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9327                 if (_ptr_hardware_id) {
9328                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9329                 } else {
9330                         r->hardware_id = NULL;
9331                 }
9332                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9333                 if (_ptr_provider) {
9334                         NDR_PULL_ALLOC(ndr, r->provider);
9335                 } else {
9336                         r->provider = NULL;
9337                 }
9338                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9339         }
9340         if (ndr_flags & NDR_BUFFERS) {
9341                 if (r->driver_name) {
9342                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9343                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9344                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9345                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9346                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9347                                 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));
9348                         }
9349                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9350                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9351                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9352                 }
9353                 if (r->architecture) {
9354                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9355                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9356                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9357                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9358                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9359                                 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));
9360                         }
9361                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9362                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9363                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9364                 }
9365                 if (r->driver_path) {
9366                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9367                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9368                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9369                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9370                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9371                                 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));
9372                         }
9373                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9374                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9375                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9376                 }
9377                 if (r->data_file) {
9378                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9379                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9380                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9381                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9382                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9383                                 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));
9384                         }
9385                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9386                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9387                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9388                 }
9389                 if (r->config_file) {
9390                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9391                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9392                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9393                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9394                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9395                                 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));
9396                         }
9397                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9398                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9399                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9400                 }
9401                 if (r->help_file) {
9402                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9403                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9404                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9405                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9406                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9407                                 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));
9408                         }
9409                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9410                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9411                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9412                 }
9413                 if (r->monitor_name) {
9414                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9415                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9416                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9417                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9418                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9419                                 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));
9420                         }
9421                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9422                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9423                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9424                 }
9425                 if (r->default_datatype) {
9426                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9427                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9428                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9429                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9430                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9431                                 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));
9432                         }
9433                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9434                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9435                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9436                 }
9437                 if (r->dependent_files) {
9438                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9439                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9440                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9441                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9442                 }
9443                 if (r->previous_names) {
9444                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9445                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9446                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9447                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9448                 }
9449                 if (r->manufacturer_name) {
9450                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9451                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9452                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9453                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9454                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9455                                 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));
9456                         }
9457                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9458                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9459                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9460                 }
9461                 if (r->manufacturer_url) {
9462                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9463                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9464                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9465                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9466                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9467                                 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));
9468                         }
9469                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9470                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9471                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9472                 }
9473                 if (r->hardware_id) {
9474                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9475                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9476                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9477                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9478                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9479                                 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));
9480                         }
9481                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9482                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9483                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9484                 }
9485                 if (r->provider) {
9486                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9487                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9488                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9489                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9490                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9491                                 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));
9492                         }
9493                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9494                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9495                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9496                 }
9497         }
9498         return NDR_ERR_SUCCESS;
9499 }
9500
9501 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
9502 {
9503         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
9504         ndr->depth++;
9505         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9506         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9507         ndr->depth++;
9508         if (r->driver_name) {
9509                 ndr_print_string(ndr, "driver_name", r->driver_name);
9510         }
9511         ndr->depth--;
9512         ndr_print_ptr(ndr, "architecture", r->architecture);
9513         ndr->depth++;
9514         if (r->architecture) {
9515                 ndr_print_string(ndr, "architecture", r->architecture);
9516         }
9517         ndr->depth--;
9518         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9519         ndr->depth++;
9520         if (r->driver_path) {
9521                 ndr_print_string(ndr, "driver_path", r->driver_path);
9522         }
9523         ndr->depth--;
9524         ndr_print_ptr(ndr, "data_file", r->data_file);
9525         ndr->depth++;
9526         if (r->data_file) {
9527                 ndr_print_string(ndr, "data_file", r->data_file);
9528         }
9529         ndr->depth--;
9530         ndr_print_ptr(ndr, "config_file", r->config_file);
9531         ndr->depth++;
9532         if (r->config_file) {
9533                 ndr_print_string(ndr, "config_file", r->config_file);
9534         }
9535         ndr->depth--;
9536         ndr_print_ptr(ndr, "help_file", r->help_file);
9537         ndr->depth++;
9538         if (r->help_file) {
9539                 ndr_print_string(ndr, "help_file", r->help_file);
9540         }
9541         ndr->depth--;
9542         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9543         ndr->depth++;
9544         if (r->monitor_name) {
9545                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9546         }
9547         ndr->depth--;
9548         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9549         ndr->depth++;
9550         if (r->default_datatype) {
9551                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9552         }
9553         ndr->depth--;
9554         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);
9555         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9556         ndr->depth++;
9557         if (r->dependent_files) {
9558                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9559         }
9560         ndr->depth--;
9561         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);
9562         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9563         ndr->depth++;
9564         if (r->previous_names) {
9565                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9566         }
9567         ndr->depth--;
9568         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9569         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9570         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9571         ndr->depth++;
9572         if (r->manufacturer_name) {
9573                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9574         }
9575         ndr->depth--;
9576         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9577         ndr->depth++;
9578         if (r->manufacturer_url) {
9579                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9580         }
9581         ndr->depth--;
9582         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9583         ndr->depth++;
9584         if (r->hardware_id) {
9585                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9586         }
9587         ndr->depth--;
9588         ndr_print_ptr(ndr, "provider", r->provider);
9589         ndr->depth++;
9590         if (r->provider) {
9591                 ndr_print_string(ndr, "provider", r->provider);
9592         }
9593         ndr->depth--;
9594         ndr->depth--;
9595 }
9596
9597 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
9598 {
9599         if (ndr_flags & NDR_SCALARS) {
9600                 NDR_CHECK(ndr_push_align(ndr, 8));
9601                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9602                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9603                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9604                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9605                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9607                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9608                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9609                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9610                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9611                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9612                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9613                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9614                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9615                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9616                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9617                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9618                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9620                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
9621                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
9622                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9623                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
9624                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
9625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9627                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
9628                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9629                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9630                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9631         }
9632         if (ndr_flags & NDR_BUFFERS) {
9633                 if (r->driver_name) {
9634                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9635                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9636                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9637                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9638                 }
9639                 if (r->architecture) {
9640                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9641                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9642                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9643                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9644                 }
9645                 if (r->driver_path) {
9646                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9647                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9648                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9649                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9650                 }
9651                 if (r->data_file) {
9652                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9653                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9654                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9655                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9656                 }
9657                 if (r->config_file) {
9658                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9659                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9660                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9661                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9662                 }
9663                 if (r->help_file) {
9664                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9665                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9666                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9667                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9668                 }
9669                 if (r->monitor_name) {
9670                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9671                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9672                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9673                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9674                 }
9675                 if (r->default_datatype) {
9676                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9677                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9678                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9679                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9680                 }
9681                 if (r->dependent_files) {
9682                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9683                 }
9684                 if (r->previous_names) {
9685                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9686                 }
9687                 if (r->manufacturer_name) {
9688                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9689                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9690                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9691                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9692                 }
9693                 if (r->manufacturer_url) {
9694                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9695                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9696                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9697                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9698                 }
9699                 if (r->hardware_id) {
9700                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9701                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9702                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9703                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9704                 }
9705                 if (r->provider) {
9706                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9707                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9708                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9709                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9710                 }
9711                 if (r->print_processor) {
9712                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9713                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9714                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9715                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9716                 }
9717                 if (r->vendor_setup) {
9718                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9719                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9720                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9721                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9722                 }
9723                 if (r->color_profiles) {
9724                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9725                 }
9726                 if (r->inf_path) {
9727                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9728                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9729                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9730                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9731                 }
9732                 if (r->core_driver_dependencies) {
9733                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9734                 }
9735         }
9736         return NDR_ERR_SUCCESS;
9737 }
9738
9739 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
9740 {
9741         uint32_t _ptr_driver_name;
9742         TALLOC_CTX *_mem_save_driver_name_0;
9743         uint32_t _ptr_architecture;
9744         TALLOC_CTX *_mem_save_architecture_0;
9745         uint32_t _ptr_driver_path;
9746         TALLOC_CTX *_mem_save_driver_path_0;
9747         uint32_t _ptr_data_file;
9748         TALLOC_CTX *_mem_save_data_file_0;
9749         uint32_t _ptr_config_file;
9750         TALLOC_CTX *_mem_save_config_file_0;
9751         uint32_t _ptr_help_file;
9752         TALLOC_CTX *_mem_save_help_file_0;
9753         uint32_t _ptr_monitor_name;
9754         TALLOC_CTX *_mem_save_monitor_name_0;
9755         uint32_t _ptr_default_datatype;
9756         TALLOC_CTX *_mem_save_default_datatype_0;
9757         uint32_t _ptr_dependent_files;
9758         TALLOC_CTX *_mem_save_dependent_files_0;
9759         uint32_t _ptr_previous_names;
9760         TALLOC_CTX *_mem_save_previous_names_0;
9761         uint32_t _ptr_manufacturer_name;
9762         TALLOC_CTX *_mem_save_manufacturer_name_0;
9763         uint32_t _ptr_manufacturer_url;
9764         TALLOC_CTX *_mem_save_manufacturer_url_0;
9765         uint32_t _ptr_hardware_id;
9766         TALLOC_CTX *_mem_save_hardware_id_0;
9767         uint32_t _ptr_provider;
9768         TALLOC_CTX *_mem_save_provider_0;
9769         uint32_t _ptr_print_processor;
9770         TALLOC_CTX *_mem_save_print_processor_0;
9771         uint32_t _ptr_vendor_setup;
9772         TALLOC_CTX *_mem_save_vendor_setup_0;
9773         uint32_t _ptr_color_profiles;
9774         TALLOC_CTX *_mem_save_color_profiles_0;
9775         uint32_t _ptr_inf_path;
9776         TALLOC_CTX *_mem_save_inf_path_0;
9777         uint32_t _ptr_core_driver_dependencies;
9778         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9779         if (ndr_flags & NDR_SCALARS) {
9780                 NDR_CHECK(ndr_pull_align(ndr, 8));
9781                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9782                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9783                 if (_ptr_driver_name) {
9784                         NDR_PULL_ALLOC(ndr, r->driver_name);
9785                 } else {
9786                         r->driver_name = NULL;
9787                 }
9788                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9789                 if (_ptr_architecture) {
9790                         NDR_PULL_ALLOC(ndr, r->architecture);
9791                 } else {
9792                         r->architecture = NULL;
9793                 }
9794                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9795                 if (_ptr_driver_path) {
9796                         NDR_PULL_ALLOC(ndr, r->driver_path);
9797                 } else {
9798                         r->driver_path = NULL;
9799                 }
9800                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9801                 if (_ptr_data_file) {
9802                         NDR_PULL_ALLOC(ndr, r->data_file);
9803                 } else {
9804                         r->data_file = NULL;
9805                 }
9806                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9807                 if (_ptr_config_file) {
9808                         NDR_PULL_ALLOC(ndr, r->config_file);
9809                 } else {
9810                         r->config_file = NULL;
9811                 }
9812                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9813                 if (_ptr_help_file) {
9814                         NDR_PULL_ALLOC(ndr, r->help_file);
9815                 } else {
9816                         r->help_file = NULL;
9817                 }
9818                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9819                 if (_ptr_monitor_name) {
9820                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9821                 } else {
9822                         r->monitor_name = NULL;
9823                 }
9824                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9825                 if (_ptr_default_datatype) {
9826                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9827                 } else {
9828                         r->default_datatype = NULL;
9829                 }
9830                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9831                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9832                 if (_ptr_dependent_files) {
9833                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9834                 } else {
9835                         r->dependent_files = NULL;
9836                 }
9837                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9838                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9839                 if (_ptr_previous_names) {
9840                         NDR_PULL_ALLOC(ndr, r->previous_names);
9841                 } else {
9842                         r->previous_names = NULL;
9843                 }
9844                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9845                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9846                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9847                 if (_ptr_manufacturer_name) {
9848                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9849                 } else {
9850                         r->manufacturer_name = NULL;
9851                 }
9852                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9853                 if (_ptr_manufacturer_url) {
9854                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9855                 } else {
9856                         r->manufacturer_url = NULL;
9857                 }
9858                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9859                 if (_ptr_hardware_id) {
9860                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9861                 } else {
9862                         r->hardware_id = NULL;
9863                 }
9864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9865                 if (_ptr_provider) {
9866                         NDR_PULL_ALLOC(ndr, r->provider);
9867                 } else {
9868                         r->provider = NULL;
9869                 }
9870                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9871                 if (_ptr_print_processor) {
9872                         NDR_PULL_ALLOC(ndr, r->print_processor);
9873                 } else {
9874                         r->print_processor = NULL;
9875                 }
9876                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9877                 if (_ptr_vendor_setup) {
9878                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9879                 } else {
9880                         r->vendor_setup = NULL;
9881                 }
9882                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9883                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9884                 if (_ptr_color_profiles) {
9885                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9886                 } else {
9887                         r->color_profiles = NULL;
9888                 }
9889                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9890                 if (_ptr_inf_path) {
9891                         NDR_PULL_ALLOC(ndr, r->inf_path);
9892                 } else {
9893                         r->inf_path = NULL;
9894                 }
9895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9897                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9898                 if (_ptr_core_driver_dependencies) {
9899                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9900                 } else {
9901                         r->core_driver_dependencies = NULL;
9902                 }
9903                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9904                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9905                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9906         }
9907         if (ndr_flags & NDR_BUFFERS) {
9908                 if (r->driver_name) {
9909                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9910                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9911                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9912                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9913                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9914                                 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));
9915                         }
9916                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9917                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9918                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9919                 }
9920                 if (r->architecture) {
9921                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9922                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9923                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9924                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9925                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9926                                 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));
9927                         }
9928                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9929                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9930                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9931                 }
9932                 if (r->driver_path) {
9933                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9934                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9935                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9936                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9937                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9938                                 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));
9939                         }
9940                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9941                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9942                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9943                 }
9944                 if (r->data_file) {
9945                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9946                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9947                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9948                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9949                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9950                                 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));
9951                         }
9952                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9953                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9954                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9955                 }
9956                 if (r->config_file) {
9957                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9958                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9959                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9960                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9961                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9962                                 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));
9963                         }
9964                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9965                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9966                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9967                 }
9968                 if (r->help_file) {
9969                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9970                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9971                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9972                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9973                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9974                                 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));
9975                         }
9976                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9977                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9978                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9979                 }
9980                 if (r->monitor_name) {
9981                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9982                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9983                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9984                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9985                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9986                                 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));
9987                         }
9988                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9989                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9990                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9991                 }
9992                 if (r->default_datatype) {
9993                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9994                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9995                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9996                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9997                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9998                                 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));
9999                         }
10000                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
10001                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
10002                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10003                 }
10004                 if (r->dependent_files) {
10005                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10006                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10007                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
10008                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10009                 }
10010                 if (r->previous_names) {
10011                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10012                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
10013                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
10014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
10015                 }
10016                 if (r->manufacturer_name) {
10017                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10018                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
10019                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
10020                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
10021                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
10022                                 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));
10023                         }
10024                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
10025                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
10026                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
10027                 }
10028                 if (r->manufacturer_url) {
10029                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
10030                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
10031                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
10032                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
10033                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
10034                                 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));
10035                         }
10036                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
10037                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
10038                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
10039                 }
10040                 if (r->hardware_id) {
10041                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
10042                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
10043                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
10044                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
10045                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
10046                                 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));
10047                         }
10048                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
10049                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
10050                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
10051                 }
10052                 if (r->provider) {
10053                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
10054                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
10055                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
10056                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
10057                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
10058                                 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));
10059                         }
10060                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
10061                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
10062                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
10063                 }
10064                 if (r->print_processor) {
10065                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
10066                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
10067                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
10068                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
10069                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
10070                                 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));
10071                         }
10072                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
10073                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
10074                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
10075                 }
10076                 if (r->vendor_setup) {
10077                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
10078                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
10079                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
10080                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
10081                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
10082                                 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));
10083                         }
10084                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
10085                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
10086                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
10087                 }
10088                 if (r->color_profiles) {
10089                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
10090                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
10091                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
10092                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
10093                 }
10094                 if (r->inf_path) {
10095                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10096                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
10097                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
10098                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
10099                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
10100                                 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));
10101                         }
10102                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
10103                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
10104                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
10105                 }
10106                 if (r->core_driver_dependencies) {
10107                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
10108                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
10109                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
10110                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
10111                 }
10112         }
10113         return NDR_ERR_SUCCESS;
10114 }
10115
10116 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
10117 {
10118         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
10119         ndr->depth++;
10120         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10121         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10122         ndr->depth++;
10123         if (r->driver_name) {
10124                 ndr_print_string(ndr, "driver_name", r->driver_name);
10125         }
10126         ndr->depth--;
10127         ndr_print_ptr(ndr, "architecture", r->architecture);
10128         ndr->depth++;
10129         if (r->architecture) {
10130                 ndr_print_string(ndr, "architecture", r->architecture);
10131         }
10132         ndr->depth--;
10133         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10134         ndr->depth++;
10135         if (r->driver_path) {
10136                 ndr_print_string(ndr, "driver_path", r->driver_path);
10137         }
10138         ndr->depth--;
10139         ndr_print_ptr(ndr, "data_file", r->data_file);
10140         ndr->depth++;
10141         if (r->data_file) {
10142                 ndr_print_string(ndr, "data_file", r->data_file);
10143         }
10144         ndr->depth--;
10145         ndr_print_ptr(ndr, "config_file", r->config_file);
10146         ndr->depth++;
10147         if (r->config_file) {
10148                 ndr_print_string(ndr, "config_file", r->config_file);
10149         }
10150         ndr->depth--;
10151         ndr_print_ptr(ndr, "help_file", r->help_file);
10152         ndr->depth++;
10153         if (r->help_file) {
10154                 ndr_print_string(ndr, "help_file", r->help_file);
10155         }
10156         ndr->depth--;
10157         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10158         ndr->depth++;
10159         if (r->monitor_name) {
10160                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10161         }
10162         ndr->depth--;
10163         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10164         ndr->depth++;
10165         if (r->default_datatype) {
10166                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10167         }
10168         ndr->depth--;
10169         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);
10170         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10171         ndr->depth++;
10172         if (r->dependent_files) {
10173                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
10174         }
10175         ndr->depth--;
10176         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);
10177         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10178         ndr->depth++;
10179         if (r->previous_names) {
10180                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
10181         }
10182         ndr->depth--;
10183         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
10184         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10185         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10186         ndr->depth++;
10187         if (r->manufacturer_name) {
10188                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10189         }
10190         ndr->depth--;
10191         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10192         ndr->depth++;
10193         if (r->manufacturer_url) {
10194                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10195         }
10196         ndr->depth--;
10197         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10198         ndr->depth++;
10199         if (r->hardware_id) {
10200                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10201         }
10202         ndr->depth--;
10203         ndr_print_ptr(ndr, "provider", r->provider);
10204         ndr->depth++;
10205         if (r->provider) {
10206                 ndr_print_string(ndr, "provider", r->provider);
10207         }
10208         ndr->depth--;
10209         ndr_print_ptr(ndr, "print_processor", r->print_processor);
10210         ndr->depth++;
10211         if (r->print_processor) {
10212                 ndr_print_string(ndr, "print_processor", r->print_processor);
10213         }
10214         ndr->depth--;
10215         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
10216         ndr->depth++;
10217         if (r->vendor_setup) {
10218                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
10219         }
10220         ndr->depth--;
10221         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);
10222         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
10223         ndr->depth++;
10224         if (r->color_profiles) {
10225                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
10226         }
10227         ndr->depth--;
10228         ndr_print_ptr(ndr, "inf_path", r->inf_path);
10229         ndr->depth++;
10230         if (r->inf_path) {
10231                 ndr_print_string(ndr, "inf_path", r->inf_path);
10232         }
10233         ndr->depth--;
10234         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
10235         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);
10236         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10237         ndr->depth++;
10238         if (r->core_driver_dependencies) {
10239                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10240         }
10241         ndr->depth--;
10242         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
10243         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
10244         ndr->depth--;
10245 }
10246
10247 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
10248 {
10249         if (ndr_flags & NDR_SCALARS) {
10250                 int level = ndr_push_get_switch_value(ndr, r);
10251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
10252                 NDR_CHECK(ndr_push_union_align(ndr, 5));
10253                 switch (level) {
10254                         case 1: {
10255                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
10256                         break; }
10257
10258                         case 2: {
10259                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
10260                         break; }
10261
10262                         case 3: {
10263                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
10264                         break; }
10265
10266                         case 4: {
10267                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
10268                         break; }
10269
10270                         case 6: {
10271                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
10272                         break; }
10273
10274                         case 8: {
10275                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
10276                         break; }
10277
10278                         default:
10279                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10280                 }
10281         }
10282         if (ndr_flags & NDR_BUFFERS) {
10283                 int level = ndr_push_get_switch_value(ndr, r);
10284                 switch (level) {
10285                         case 1:
10286                                 if (r->info1) {
10287                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10288                                 }
10289                         break;
10290
10291                         case 2:
10292                                 if (r->info2) {
10293                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10294                                 }
10295                         break;
10296
10297                         case 3:
10298                                 if (r->info3) {
10299                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10300                                 }
10301                         break;
10302
10303                         case 4:
10304                                 if (r->info4) {
10305                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10306                                 }
10307                         break;
10308
10309                         case 6:
10310                                 if (r->info6) {
10311                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10312                                 }
10313                         break;
10314
10315                         case 8:
10316                                 if (r->info8) {
10317                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10318                                 }
10319                         break;
10320
10321                         default:
10322                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10323                 }
10324         }
10325         return NDR_ERR_SUCCESS;
10326 }
10327
10328 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
10329 {
10330         int level;
10331         uint32_t _level;
10332         TALLOC_CTX *_mem_save_info1_0;
10333         TALLOC_CTX *_mem_save_info2_0;
10334         TALLOC_CTX *_mem_save_info3_0;
10335         TALLOC_CTX *_mem_save_info4_0;
10336         TALLOC_CTX *_mem_save_info6_0;
10337         TALLOC_CTX *_mem_save_info8_0;
10338         level = ndr_pull_get_switch_value(ndr, r);
10339         if (ndr_flags & NDR_SCALARS) {
10340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
10341                 if (_level != level) {
10342                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10343                 }
10344                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
10345                 switch (level) {
10346                         case 1: {
10347                                 uint32_t _ptr_info1;
10348                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
10349                                 if (_ptr_info1) {
10350                                         NDR_PULL_ALLOC(ndr, r->info1);
10351                                 } else {
10352                                         r->info1 = NULL;
10353                                 }
10354                         break; }
10355
10356                         case 2: {
10357                                 uint32_t _ptr_info2;
10358                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
10359                                 if (_ptr_info2) {
10360                                         NDR_PULL_ALLOC(ndr, r->info2);
10361                                 } else {
10362                                         r->info2 = NULL;
10363                                 }
10364                         break; }
10365
10366                         case 3: {
10367                                 uint32_t _ptr_info3;
10368                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
10369                                 if (_ptr_info3) {
10370                                         NDR_PULL_ALLOC(ndr, r->info3);
10371                                 } else {
10372                                         r->info3 = NULL;
10373                                 }
10374                         break; }
10375
10376                         case 4: {
10377                                 uint32_t _ptr_info4;
10378                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
10379                                 if (_ptr_info4) {
10380                                         NDR_PULL_ALLOC(ndr, r->info4);
10381                                 } else {
10382                                         r->info4 = NULL;
10383                                 }
10384                         break; }
10385
10386                         case 6: {
10387                                 uint32_t _ptr_info6;
10388                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
10389                                 if (_ptr_info6) {
10390                                         NDR_PULL_ALLOC(ndr, r->info6);
10391                                 } else {
10392                                         r->info6 = NULL;
10393                                 }
10394                         break; }
10395
10396                         case 8: {
10397                                 uint32_t _ptr_info8;
10398                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
10399                                 if (_ptr_info8) {
10400                                         NDR_PULL_ALLOC(ndr, r->info8);
10401                                 } else {
10402                                         r->info8 = NULL;
10403                                 }
10404                         break; }
10405
10406                         default:
10407                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10408                 }
10409         }
10410         if (ndr_flags & NDR_BUFFERS) {
10411                 switch (level) {
10412                         case 1:
10413                                 if (r->info1) {
10414                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
10415                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
10416                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10417                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
10418                                 }
10419                         break;
10420
10421                         case 2:
10422                                 if (r->info2) {
10423                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
10424                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
10425                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10426                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
10427                                 }
10428                         break;
10429
10430                         case 3:
10431                                 if (r->info3) {
10432                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
10433                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
10434                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10435                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
10436                                 }
10437                         break;
10438
10439                         case 4:
10440                                 if (r->info4) {
10441                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
10442                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
10443                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10444                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
10445                                 }
10446                         break;
10447
10448                         case 6:
10449                                 if (r->info6) {
10450                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
10451                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
10452                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10453                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
10454                                 }
10455                         break;
10456
10457                         case 8:
10458                                 if (r->info8) {
10459                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
10460                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
10461                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10462                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
10463                                 }
10464                         break;
10465
10466                         default:
10467                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10468                 }
10469         }
10470         return NDR_ERR_SUCCESS;
10471 }
10472
10473 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
10474 {
10475         int level;
10476         level = ndr_print_get_switch_value(ndr, r);
10477         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
10478         switch (level) {
10479                 case 1:
10480                         ndr_print_ptr(ndr, "info1", r->info1);
10481                         ndr->depth++;
10482                         if (r->info1) {
10483                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
10484                         }
10485                         ndr->depth--;
10486                 break;
10487
10488                 case 2:
10489                         ndr_print_ptr(ndr, "info2", r->info2);
10490                         ndr->depth++;
10491                         if (r->info2) {
10492                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
10493                         }
10494                         ndr->depth--;
10495                 break;
10496
10497                 case 3:
10498                         ndr_print_ptr(ndr, "info3", r->info3);
10499                         ndr->depth++;
10500                         if (r->info3) {
10501                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
10502                         }
10503                         ndr->depth--;
10504                 break;
10505
10506                 case 4:
10507                         ndr_print_ptr(ndr, "info4", r->info4);
10508                         ndr->depth++;
10509                         if (r->info4) {
10510                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
10511                         }
10512                         ndr->depth--;
10513                 break;
10514
10515                 case 6:
10516                         ndr_print_ptr(ndr, "info6", r->info6);
10517                         ndr->depth++;
10518                         if (r->info6) {
10519                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
10520                         }
10521                         ndr->depth--;
10522                 break;
10523
10524                 case 8:
10525                         ndr_print_ptr(ndr, "info8", r->info8);
10526                         ndr->depth++;
10527                         if (r->info8) {
10528                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
10529                         }
10530                         ndr->depth--;
10531                 break;
10532
10533                 default:
10534                         ndr_print_bad_level(ndr, name, level);
10535         }
10536 }
10537
10538 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
10539 {
10540         if (ndr_flags & NDR_SCALARS) {
10541                 NDR_CHECK(ndr_push_align(ndr, 5));
10542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
10543                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
10544                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10545                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10546         }
10547         if (ndr_flags & NDR_BUFFERS) {
10548                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10549         }
10550         return NDR_ERR_SUCCESS;
10551 }
10552
10553 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
10554 {
10555         if (ndr_flags & NDR_SCALARS) {
10556                 NDR_CHECK(ndr_pull_align(ndr, 5));
10557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
10558                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
10559                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10560                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10561         }
10562         if (ndr_flags & NDR_BUFFERS) {
10563                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10564         }
10565         return NDR_ERR_SUCCESS;
10566 }
10567
10568 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
10569 {
10570         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
10571         ndr->depth++;
10572         ndr_print_uint32(ndr, "level", r->level);
10573         ndr_print_set_switch_value(ndr, &r->info, r->level);
10574         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
10575         ndr->depth--;
10576 }
10577
10578 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
10579 {
10580         if (ndr_flags & NDR_SCALARS) {
10581                 NDR_CHECK(ndr_push_align(ndr, 5));
10582                 {
10583                         uint32_t _flags_save_string = ndr->flags;
10584                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10585                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10586                         ndr->flags = _flags_save_string;
10587                 }
10588                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10589         }
10590         if (ndr_flags & NDR_BUFFERS) {
10591                 {
10592                         uint32_t _flags_save_string = ndr->flags;
10593                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10594                         if (r->driver_name) {
10595                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10596                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10597                         }
10598                         ndr->flags = _flags_save_string;
10599                 }
10600         }
10601         return NDR_ERR_SUCCESS;
10602 }
10603
10604 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
10605 {
10606         uint32_t _ptr_driver_name;
10607         TALLOC_CTX *_mem_save_driver_name_0;
10608         if (ndr_flags & NDR_SCALARS) {
10609                 NDR_CHECK(ndr_pull_align(ndr, 5));
10610                 {
10611                         uint32_t _flags_save_string = ndr->flags;
10612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10613                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10614                         if (_ptr_driver_name) {
10615                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10616                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10617                         } else {
10618                                 r->driver_name = NULL;
10619                         }
10620                         ndr->flags = _flags_save_string;
10621                 }
10622                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10623         }
10624         if (ndr_flags & NDR_BUFFERS) {
10625                 {
10626                         uint32_t _flags_save_string = ndr->flags;
10627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10628                         if (r->driver_name) {
10629                                 uint32_t _relative_save_offset;
10630                                 _relative_save_offset = ndr->offset;
10631                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10632                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10633                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10634                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10635                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10636                                 if (ndr->offset > ndr->relative_highest_offset) {
10637                                         ndr->relative_highest_offset = ndr->offset;
10638                                 }
10639                                 ndr->offset = _relative_save_offset;
10640                         }
10641                         ndr->flags = _flags_save_string;
10642                 }
10643         }
10644         return NDR_ERR_SUCCESS;
10645 }
10646
10647 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
10648 {
10649         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
10650         ndr->depth++;
10651         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10652         ndr->depth++;
10653         if (r->driver_name) {
10654                 ndr_print_string(ndr, "driver_name", r->driver_name);
10655         }
10656         ndr->depth--;
10657         ndr->depth--;
10658 }
10659
10660 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
10661 {
10662         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
10663 }
10664
10665 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
10666 {
10667         if (ndr_flags & NDR_SCALARS) {
10668                 NDR_CHECK(ndr_push_align(ndr, 5));
10669                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10670                 {
10671                         uint32_t _flags_save_string = ndr->flags;
10672                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10673                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10674                         ndr->flags = _flags_save_string;
10675                 }
10676                 {
10677                         uint32_t _flags_save_string = ndr->flags;
10678                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10679                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10680                         ndr->flags = _flags_save_string;
10681                 }
10682                 {
10683                         uint32_t _flags_save_string = ndr->flags;
10684                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10685                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10686                         ndr->flags = _flags_save_string;
10687                 }
10688                 {
10689                         uint32_t _flags_save_string = ndr->flags;
10690                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10691                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10692                         ndr->flags = _flags_save_string;
10693                 }
10694                 {
10695                         uint32_t _flags_save_string = ndr->flags;
10696                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10697                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10698                         ndr->flags = _flags_save_string;
10699                 }
10700                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10701         }
10702         if (ndr_flags & NDR_BUFFERS) {
10703                 {
10704                         uint32_t _flags_save_string = ndr->flags;
10705                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10706                         if (r->driver_name) {
10707                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10708                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10709                         }
10710                         ndr->flags = _flags_save_string;
10711                 }
10712                 {
10713                         uint32_t _flags_save_string = ndr->flags;
10714                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10715                         if (r->architecture) {
10716                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10717                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10718                         }
10719                         ndr->flags = _flags_save_string;
10720                 }
10721                 {
10722                         uint32_t _flags_save_string = ndr->flags;
10723                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10724                         if (r->driver_path) {
10725                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10726                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10727                         }
10728                         ndr->flags = _flags_save_string;
10729                 }
10730                 {
10731                         uint32_t _flags_save_string = ndr->flags;
10732                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10733                         if (r->data_file) {
10734                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10735                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10736                         }
10737                         ndr->flags = _flags_save_string;
10738                 }
10739                 {
10740                         uint32_t _flags_save_string = ndr->flags;
10741                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10742                         if (r->config_file) {
10743                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10744                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10745                         }
10746                         ndr->flags = _flags_save_string;
10747                 }
10748         }
10749         return NDR_ERR_SUCCESS;
10750 }
10751
10752 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
10753 {
10754         uint32_t _ptr_driver_name;
10755         TALLOC_CTX *_mem_save_driver_name_0;
10756         uint32_t _ptr_architecture;
10757         TALLOC_CTX *_mem_save_architecture_0;
10758         uint32_t _ptr_driver_path;
10759         TALLOC_CTX *_mem_save_driver_path_0;
10760         uint32_t _ptr_data_file;
10761         TALLOC_CTX *_mem_save_data_file_0;
10762         uint32_t _ptr_config_file;
10763         TALLOC_CTX *_mem_save_config_file_0;
10764         if (ndr_flags & NDR_SCALARS) {
10765                 NDR_CHECK(ndr_pull_align(ndr, 5));
10766                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10767                 {
10768                         uint32_t _flags_save_string = ndr->flags;
10769                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10770                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10771                         if (_ptr_driver_name) {
10772                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10773                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10774                         } else {
10775                                 r->driver_name = NULL;
10776                         }
10777                         ndr->flags = _flags_save_string;
10778                 }
10779                 {
10780                         uint32_t _flags_save_string = ndr->flags;
10781                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10782                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10783                         if (_ptr_architecture) {
10784                                 NDR_PULL_ALLOC(ndr, r->architecture);
10785                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10786                         } else {
10787                                 r->architecture = NULL;
10788                         }
10789                         ndr->flags = _flags_save_string;
10790                 }
10791                 {
10792                         uint32_t _flags_save_string = ndr->flags;
10793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10794                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10795                         if (_ptr_driver_path) {
10796                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10797                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10798                         } else {
10799                                 r->driver_path = NULL;
10800                         }
10801                         ndr->flags = _flags_save_string;
10802                 }
10803                 {
10804                         uint32_t _flags_save_string = ndr->flags;
10805                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10806                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10807                         if (_ptr_data_file) {
10808                                 NDR_PULL_ALLOC(ndr, r->data_file);
10809                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10810                         } else {
10811                                 r->data_file = NULL;
10812                         }
10813                         ndr->flags = _flags_save_string;
10814                 }
10815                 {
10816                         uint32_t _flags_save_string = ndr->flags;
10817                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10818                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10819                         if (_ptr_config_file) {
10820                                 NDR_PULL_ALLOC(ndr, r->config_file);
10821                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10822                         } else {
10823                                 r->config_file = NULL;
10824                         }
10825                         ndr->flags = _flags_save_string;
10826                 }
10827                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10828         }
10829         if (ndr_flags & NDR_BUFFERS) {
10830                 {
10831                         uint32_t _flags_save_string = ndr->flags;
10832                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10833                         if (r->driver_name) {
10834                                 uint32_t _relative_save_offset;
10835                                 _relative_save_offset = ndr->offset;
10836                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10837                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10838                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10839                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10840                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10841                                 if (ndr->offset > ndr->relative_highest_offset) {
10842                                         ndr->relative_highest_offset = ndr->offset;
10843                                 }
10844                                 ndr->offset = _relative_save_offset;
10845                         }
10846                         ndr->flags = _flags_save_string;
10847                 }
10848                 {
10849                         uint32_t _flags_save_string = ndr->flags;
10850                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10851                         if (r->architecture) {
10852                                 uint32_t _relative_save_offset;
10853                                 _relative_save_offset = ndr->offset;
10854                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10855                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10856                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10857                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10858                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10859                                 if (ndr->offset > ndr->relative_highest_offset) {
10860                                         ndr->relative_highest_offset = ndr->offset;
10861                                 }
10862                                 ndr->offset = _relative_save_offset;
10863                         }
10864                         ndr->flags = _flags_save_string;
10865                 }
10866                 {
10867                         uint32_t _flags_save_string = ndr->flags;
10868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10869                         if (r->driver_path) {
10870                                 uint32_t _relative_save_offset;
10871                                 _relative_save_offset = ndr->offset;
10872                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10873                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10874                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10875                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10876                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10877                                 if (ndr->offset > ndr->relative_highest_offset) {
10878                                         ndr->relative_highest_offset = ndr->offset;
10879                                 }
10880                                 ndr->offset = _relative_save_offset;
10881                         }
10882                         ndr->flags = _flags_save_string;
10883                 }
10884                 {
10885                         uint32_t _flags_save_string = ndr->flags;
10886                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10887                         if (r->data_file) {
10888                                 uint32_t _relative_save_offset;
10889                                 _relative_save_offset = ndr->offset;
10890                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10891                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10892                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10893                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10894                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10895                                 if (ndr->offset > ndr->relative_highest_offset) {
10896                                         ndr->relative_highest_offset = ndr->offset;
10897                                 }
10898                                 ndr->offset = _relative_save_offset;
10899                         }
10900                         ndr->flags = _flags_save_string;
10901                 }
10902                 {
10903                         uint32_t _flags_save_string = ndr->flags;
10904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10905                         if (r->config_file) {
10906                                 uint32_t _relative_save_offset;
10907                                 _relative_save_offset = ndr->offset;
10908                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10909                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10910                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10911                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10912                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10913                                 if (ndr->offset > ndr->relative_highest_offset) {
10914                                         ndr->relative_highest_offset = ndr->offset;
10915                                 }
10916                                 ndr->offset = _relative_save_offset;
10917                         }
10918                         ndr->flags = _flags_save_string;
10919                 }
10920         }
10921         return NDR_ERR_SUCCESS;
10922 }
10923
10924 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10925 {
10926         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10927         ndr->depth++;
10928         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10929         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10930         ndr->depth++;
10931         if (r->driver_name) {
10932                 ndr_print_string(ndr, "driver_name", r->driver_name);
10933         }
10934         ndr->depth--;
10935         ndr_print_ptr(ndr, "architecture", r->architecture);
10936         ndr->depth++;
10937         if (r->architecture) {
10938                 ndr_print_string(ndr, "architecture", r->architecture);
10939         }
10940         ndr->depth--;
10941         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10942         ndr->depth++;
10943         if (r->driver_path) {
10944                 ndr_print_string(ndr, "driver_path", r->driver_path);
10945         }
10946         ndr->depth--;
10947         ndr_print_ptr(ndr, "data_file", r->data_file);
10948         ndr->depth++;
10949         if (r->data_file) {
10950                 ndr_print_string(ndr, "data_file", r->data_file);
10951         }
10952         ndr->depth--;
10953         ndr_print_ptr(ndr, "config_file", r->config_file);
10954         ndr->depth++;
10955         if (r->config_file) {
10956                 ndr_print_string(ndr, "config_file", r->config_file);
10957         }
10958         ndr->depth--;
10959         ndr->depth--;
10960 }
10961
10962 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10963 {
10964         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10965 }
10966
10967 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10968 {
10969         if (ndr_flags & NDR_SCALARS) {
10970                 NDR_CHECK(ndr_push_align(ndr, 5));
10971                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
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_name));
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->architecture));
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->driver_path));
10988                         ndr->flags = _flags_save_string;
10989                 }
10990                 {
10991                         uint32_t _flags_save_string = ndr->flags;
10992                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10993                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10994                         ndr->flags = _flags_save_string;
10995                 }
10996                 {
10997                         uint32_t _flags_save_string = ndr->flags;
10998                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10999                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11000                         ndr->flags = _flags_save_string;
11001                 }
11002                 {
11003                         uint32_t _flags_save_string = ndr->flags;
11004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11005                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11006                         ndr->flags = _flags_save_string;
11007                 }
11008                 {
11009                         uint32_t _flags_save_string_array = ndr->flags;
11010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11011                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11012                         ndr->flags = _flags_save_string_array;
11013                 }
11014                 {
11015                         uint32_t _flags_save_string = ndr->flags;
11016                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11017                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11018                         ndr->flags = _flags_save_string;
11019                 }
11020                 {
11021                         uint32_t _flags_save_string = ndr->flags;
11022                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11023                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11024                         ndr->flags = _flags_save_string;
11025                 }
11026                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11027         }
11028         if (ndr_flags & NDR_BUFFERS) {
11029                 {
11030                         uint32_t _flags_save_string = ndr->flags;
11031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11032                         if (r->driver_name) {
11033                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11034                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11035                         }
11036                         ndr->flags = _flags_save_string;
11037                 }
11038                 {
11039                         uint32_t _flags_save_string = ndr->flags;
11040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11041                         if (r->architecture) {
11042                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11043                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11044                         }
11045                         ndr->flags = _flags_save_string;
11046                 }
11047                 {
11048                         uint32_t _flags_save_string = ndr->flags;
11049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11050                         if (r->driver_path) {
11051                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11052                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11053                         }
11054                         ndr->flags = _flags_save_string;
11055                 }
11056                 {
11057                         uint32_t _flags_save_string = ndr->flags;
11058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11059                         if (r->data_file) {
11060                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11061                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11062                         }
11063                         ndr->flags = _flags_save_string;
11064                 }
11065                 {
11066                         uint32_t _flags_save_string = ndr->flags;
11067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11068                         if (r->config_file) {
11069                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11070                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
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                         if (r->help_file) {
11078                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11079                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11080                         }
11081                         ndr->flags = _flags_save_string;
11082                 }
11083                 {
11084                         uint32_t _flags_save_string_array = ndr->flags;
11085                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11086                         if (r->dependent_files) {
11087                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11088                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11089                         }
11090                         ndr->flags = _flags_save_string_array;
11091                 }
11092                 {
11093                         uint32_t _flags_save_string = ndr->flags;
11094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11095                         if (r->monitor_name) {
11096                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11097                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11098                         }
11099                         ndr->flags = _flags_save_string;
11100                 }
11101                 {
11102                         uint32_t _flags_save_string = ndr->flags;
11103                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11104                         if (r->default_datatype) {
11105                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11106                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11107                         }
11108                         ndr->flags = _flags_save_string;
11109                 }
11110         }
11111         return NDR_ERR_SUCCESS;
11112 }
11113
11114 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
11115 {
11116         uint32_t _ptr_driver_name;
11117         TALLOC_CTX *_mem_save_driver_name_0;
11118         uint32_t _ptr_architecture;
11119         TALLOC_CTX *_mem_save_architecture_0;
11120         uint32_t _ptr_driver_path;
11121         TALLOC_CTX *_mem_save_driver_path_0;
11122         uint32_t _ptr_data_file;
11123         TALLOC_CTX *_mem_save_data_file_0;
11124         uint32_t _ptr_config_file;
11125         TALLOC_CTX *_mem_save_config_file_0;
11126         uint32_t _ptr_help_file;
11127         TALLOC_CTX *_mem_save_help_file_0;
11128         uint32_t _ptr_dependent_files;
11129         TALLOC_CTX *_mem_save_dependent_files_0;
11130         uint32_t _ptr_monitor_name;
11131         TALLOC_CTX *_mem_save_monitor_name_0;
11132         uint32_t _ptr_default_datatype;
11133         TALLOC_CTX *_mem_save_default_datatype_0;
11134         if (ndr_flags & NDR_SCALARS) {
11135                 NDR_CHECK(ndr_pull_align(ndr, 5));
11136                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11137                 {
11138                         uint32_t _flags_save_string = ndr->flags;
11139                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11140                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11141                         if (_ptr_driver_name) {
11142                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11143                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11144                         } else {
11145                                 r->driver_name = NULL;
11146                         }
11147                         ndr->flags = _flags_save_string;
11148                 }
11149                 {
11150                         uint32_t _flags_save_string = ndr->flags;
11151                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11152                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11153                         if (_ptr_architecture) {
11154                                 NDR_PULL_ALLOC(ndr, r->architecture);
11155                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11156                         } else {
11157                                 r->architecture = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11165                         if (_ptr_driver_path) {
11166                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11167                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11168                         } else {
11169                                 r->driver_path = NULL;
11170                         }
11171                         ndr->flags = _flags_save_string;
11172                 }
11173                 {
11174                         uint32_t _flags_save_string = ndr->flags;
11175                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11176                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11177                         if (_ptr_data_file) {
11178                                 NDR_PULL_ALLOC(ndr, r->data_file);
11179                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11180                         } else {
11181                                 r->data_file = NULL;
11182                         }
11183                         ndr->flags = _flags_save_string;
11184                 }
11185                 {
11186                         uint32_t _flags_save_string = ndr->flags;
11187                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11188                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11189                         if (_ptr_config_file) {
11190                                 NDR_PULL_ALLOC(ndr, r->config_file);
11191                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11192                         } else {
11193                                 r->config_file = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11201                         if (_ptr_help_file) {
11202                                 NDR_PULL_ALLOC(ndr, r->help_file);
11203                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11204                         } else {
11205                                 r->help_file = NULL;
11206                         }
11207                         ndr->flags = _flags_save_string;
11208                 }
11209                 {
11210                         uint32_t _flags_save_string_array = ndr->flags;
11211                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11212                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11213                         if (_ptr_dependent_files) {
11214                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11215                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11216                         } else {
11217                                 r->dependent_files = NULL;
11218                         }
11219                         ndr->flags = _flags_save_string_array;
11220                 }
11221                 {
11222                         uint32_t _flags_save_string = ndr->flags;
11223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11224                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11225                         if (_ptr_monitor_name) {
11226                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11227                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11228                         } else {
11229                                 r->monitor_name = NULL;
11230                         }
11231                         ndr->flags = _flags_save_string;
11232                 }
11233                 {
11234                         uint32_t _flags_save_string = ndr->flags;
11235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11236                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11237                         if (_ptr_default_datatype) {
11238                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11239                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11240                         } else {
11241                                 r->default_datatype = NULL;
11242                         }
11243                         ndr->flags = _flags_save_string;
11244                 }
11245                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11246         }
11247         if (ndr_flags & NDR_BUFFERS) {
11248                 {
11249                         uint32_t _flags_save_string = ndr->flags;
11250                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11251                         if (r->driver_name) {
11252                                 uint32_t _relative_save_offset;
11253                                 _relative_save_offset = ndr->offset;
11254                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11255                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11256                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11257                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11258                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11259                                 if (ndr->offset > ndr->relative_highest_offset) {
11260                                         ndr->relative_highest_offset = ndr->offset;
11261                                 }
11262                                 ndr->offset = _relative_save_offset;
11263                         }
11264                         ndr->flags = _flags_save_string;
11265                 }
11266                 {
11267                         uint32_t _flags_save_string = ndr->flags;
11268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11269                         if (r->architecture) {
11270                                 uint32_t _relative_save_offset;
11271                                 _relative_save_offset = ndr->offset;
11272                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11273                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11274                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11275                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11276                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11277                                 if (ndr->offset > ndr->relative_highest_offset) {
11278                                         ndr->relative_highest_offset = ndr->offset;
11279                                 }
11280                                 ndr->offset = _relative_save_offset;
11281                         }
11282                         ndr->flags = _flags_save_string;
11283                 }
11284                 {
11285                         uint32_t _flags_save_string = ndr->flags;
11286                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11287                         if (r->driver_path) {
11288                                 uint32_t _relative_save_offset;
11289                                 _relative_save_offset = ndr->offset;
11290                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11291                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11292                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11293                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11294                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11295                                 if (ndr->offset > ndr->relative_highest_offset) {
11296                                         ndr->relative_highest_offset = ndr->offset;
11297                                 }
11298                                 ndr->offset = _relative_save_offset;
11299                         }
11300                         ndr->flags = _flags_save_string;
11301                 }
11302                 {
11303                         uint32_t _flags_save_string = ndr->flags;
11304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11305                         if (r->data_file) {
11306                                 uint32_t _relative_save_offset;
11307                                 _relative_save_offset = ndr->offset;
11308                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11309                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11310                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11311                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11312                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11313                                 if (ndr->offset > ndr->relative_highest_offset) {
11314                                         ndr->relative_highest_offset = ndr->offset;
11315                                 }
11316                                 ndr->offset = _relative_save_offset;
11317                         }
11318                         ndr->flags = _flags_save_string;
11319                 }
11320                 {
11321                         uint32_t _flags_save_string = ndr->flags;
11322                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11323                         if (r->config_file) {
11324                                 uint32_t _relative_save_offset;
11325                                 _relative_save_offset = ndr->offset;
11326                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11327                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11328                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11329                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11330                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11331                                 if (ndr->offset > ndr->relative_highest_offset) {
11332                                         ndr->relative_highest_offset = ndr->offset;
11333                                 }
11334                                 ndr->offset = _relative_save_offset;
11335                         }
11336                         ndr->flags = _flags_save_string;
11337                 }
11338                 {
11339                         uint32_t _flags_save_string = ndr->flags;
11340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11341                         if (r->help_file) {
11342                                 uint32_t _relative_save_offset;
11343                                 _relative_save_offset = ndr->offset;
11344                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11345                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11346                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11347                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11348                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11349                                 if (ndr->offset > ndr->relative_highest_offset) {
11350                                         ndr->relative_highest_offset = ndr->offset;
11351                                 }
11352                                 ndr->offset = _relative_save_offset;
11353                         }
11354                         ndr->flags = _flags_save_string;
11355                 }
11356                 {
11357                         uint32_t _flags_save_string_array = ndr->flags;
11358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11359                         if (r->dependent_files) {
11360                                 uint32_t _relative_save_offset;
11361                                 _relative_save_offset = ndr->offset;
11362                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11363                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11364                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11365                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11366                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11367                                 if (ndr->offset > ndr->relative_highest_offset) {
11368                                         ndr->relative_highest_offset = ndr->offset;
11369                                 }
11370                                 ndr->offset = _relative_save_offset;
11371                         }
11372                         ndr->flags = _flags_save_string_array;
11373                 }
11374                 {
11375                         uint32_t _flags_save_string = ndr->flags;
11376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11377                         if (r->monitor_name) {
11378                                 uint32_t _relative_save_offset;
11379                                 _relative_save_offset = ndr->offset;
11380                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11381                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11382                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11383                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11384                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11385                                 if (ndr->offset > ndr->relative_highest_offset) {
11386                                         ndr->relative_highest_offset = ndr->offset;
11387                                 }
11388                                 ndr->offset = _relative_save_offset;
11389                         }
11390                         ndr->flags = _flags_save_string;
11391                 }
11392                 {
11393                         uint32_t _flags_save_string = ndr->flags;
11394                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11395                         if (r->default_datatype) {
11396                                 uint32_t _relative_save_offset;
11397                                 _relative_save_offset = ndr->offset;
11398                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11399                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11400                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11401                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11402                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11403                                 if (ndr->offset > ndr->relative_highest_offset) {
11404                                         ndr->relative_highest_offset = ndr->offset;
11405                                 }
11406                                 ndr->offset = _relative_save_offset;
11407                         }
11408                         ndr->flags = _flags_save_string;
11409                 }
11410         }
11411         return NDR_ERR_SUCCESS;
11412 }
11413
11414 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
11415 {
11416         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
11417         ndr->depth++;
11418         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11419         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11420         ndr->depth++;
11421         if (r->driver_name) {
11422                 ndr_print_string(ndr, "driver_name", r->driver_name);
11423         }
11424         ndr->depth--;
11425         ndr_print_ptr(ndr, "architecture", r->architecture);
11426         ndr->depth++;
11427         if (r->architecture) {
11428                 ndr_print_string(ndr, "architecture", r->architecture);
11429         }
11430         ndr->depth--;
11431         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11432         ndr->depth++;
11433         if (r->driver_path) {
11434                 ndr_print_string(ndr, "driver_path", r->driver_path);
11435         }
11436         ndr->depth--;
11437         ndr_print_ptr(ndr, "data_file", r->data_file);
11438         ndr->depth++;
11439         if (r->data_file) {
11440                 ndr_print_string(ndr, "data_file", r->data_file);
11441         }
11442         ndr->depth--;
11443         ndr_print_ptr(ndr, "config_file", r->config_file);
11444         ndr->depth++;
11445         if (r->config_file) {
11446                 ndr_print_string(ndr, "config_file", r->config_file);
11447         }
11448         ndr->depth--;
11449         ndr_print_ptr(ndr, "help_file", r->help_file);
11450         ndr->depth++;
11451         if (r->help_file) {
11452                 ndr_print_string(ndr, "help_file", r->help_file);
11453         }
11454         ndr->depth--;
11455         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11456         ndr->depth++;
11457         if (r->dependent_files) {
11458                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11459         }
11460         ndr->depth--;
11461         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11462         ndr->depth++;
11463         if (r->monitor_name) {
11464                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11465         }
11466         ndr->depth--;
11467         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11468         ndr->depth++;
11469         if (r->default_datatype) {
11470                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11471         }
11472         ndr->depth--;
11473         ndr->depth--;
11474 }
11475
11476 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
11477 {
11478         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
11479 }
11480
11481 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
11482 {
11483         if (ndr_flags & NDR_SCALARS) {
11484                 NDR_CHECK(ndr_push_align(ndr, 5));
11485                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11486                 {
11487                         uint32_t _flags_save_string = ndr->flags;
11488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11489                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11490                         ndr->flags = _flags_save_string;
11491                 }
11492                 {
11493                         uint32_t _flags_save_string = ndr->flags;
11494                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11495                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11496                         ndr->flags = _flags_save_string;
11497                 }
11498                 {
11499                         uint32_t _flags_save_string = ndr->flags;
11500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11501                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11502                         ndr->flags = _flags_save_string;
11503                 }
11504                 {
11505                         uint32_t _flags_save_string = ndr->flags;
11506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11507                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11508                         ndr->flags = _flags_save_string;
11509                 }
11510                 {
11511                         uint32_t _flags_save_string = ndr->flags;
11512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11513                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11514                         ndr->flags = _flags_save_string;
11515                 }
11516                 {
11517                         uint32_t _flags_save_string = ndr->flags;
11518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11519                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11520                         ndr->flags = _flags_save_string;
11521                 }
11522                 {
11523                         uint32_t _flags_save_string_array = ndr->flags;
11524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11525                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11526                         ndr->flags = _flags_save_string_array;
11527                 }
11528                 {
11529                         uint32_t _flags_save_string = ndr->flags;
11530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11531                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11532                         ndr->flags = _flags_save_string;
11533                 }
11534                 {
11535                         uint32_t _flags_save_string = ndr->flags;
11536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11537                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11538                         ndr->flags = _flags_save_string;
11539                 }
11540                 {
11541                         uint32_t _flags_save_string_array = ndr->flags;
11542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11543                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11544                         ndr->flags = _flags_save_string_array;
11545                 }
11546                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11547         }
11548         if (ndr_flags & NDR_BUFFERS) {
11549                 {
11550                         uint32_t _flags_save_string = ndr->flags;
11551                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11552                         if (r->driver_name) {
11553                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11554                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11555                         }
11556                         ndr->flags = _flags_save_string;
11557                 }
11558                 {
11559                         uint32_t _flags_save_string = ndr->flags;
11560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11561                         if (r->architecture) {
11562                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11563                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11564                         }
11565                         ndr->flags = _flags_save_string;
11566                 }
11567                 {
11568                         uint32_t _flags_save_string = ndr->flags;
11569                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11570                         if (r->driver_path) {
11571                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11572                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11573                         }
11574                         ndr->flags = _flags_save_string;
11575                 }
11576                 {
11577                         uint32_t _flags_save_string = ndr->flags;
11578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11579                         if (r->data_file) {
11580                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11581                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11582                         }
11583                         ndr->flags = _flags_save_string;
11584                 }
11585                 {
11586                         uint32_t _flags_save_string = ndr->flags;
11587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11588                         if (r->config_file) {
11589                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11590                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11591                         }
11592                         ndr->flags = _flags_save_string;
11593                 }
11594                 {
11595                         uint32_t _flags_save_string = ndr->flags;
11596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11597                         if (r->help_file) {
11598                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11599                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11600                         }
11601                         ndr->flags = _flags_save_string;
11602                 }
11603                 {
11604                         uint32_t _flags_save_string_array = ndr->flags;
11605                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11606                         if (r->dependent_files) {
11607                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11608                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11609                         }
11610                         ndr->flags = _flags_save_string_array;
11611                 }
11612                 {
11613                         uint32_t _flags_save_string = ndr->flags;
11614                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11615                         if (r->monitor_name) {
11616                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11617                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11618                         }
11619                         ndr->flags = _flags_save_string;
11620                 }
11621                 {
11622                         uint32_t _flags_save_string = ndr->flags;
11623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11624                         if (r->default_datatype) {
11625                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11626                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11627                         }
11628                         ndr->flags = _flags_save_string;
11629                 }
11630                 {
11631                         uint32_t _flags_save_string_array = ndr->flags;
11632                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11633                         if (r->previous_names) {
11634                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11635                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11636                         }
11637                         ndr->flags = _flags_save_string_array;
11638                 }
11639         }
11640         return NDR_ERR_SUCCESS;
11641 }
11642
11643 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
11644 {
11645         uint32_t _ptr_driver_name;
11646         TALLOC_CTX *_mem_save_driver_name_0;
11647         uint32_t _ptr_architecture;
11648         TALLOC_CTX *_mem_save_architecture_0;
11649         uint32_t _ptr_driver_path;
11650         TALLOC_CTX *_mem_save_driver_path_0;
11651         uint32_t _ptr_data_file;
11652         TALLOC_CTX *_mem_save_data_file_0;
11653         uint32_t _ptr_config_file;
11654         TALLOC_CTX *_mem_save_config_file_0;
11655         uint32_t _ptr_help_file;
11656         TALLOC_CTX *_mem_save_help_file_0;
11657         uint32_t _ptr_dependent_files;
11658         TALLOC_CTX *_mem_save_dependent_files_0;
11659         uint32_t _ptr_monitor_name;
11660         TALLOC_CTX *_mem_save_monitor_name_0;
11661         uint32_t _ptr_default_datatype;
11662         TALLOC_CTX *_mem_save_default_datatype_0;
11663         uint32_t _ptr_previous_names;
11664         TALLOC_CTX *_mem_save_previous_names_0;
11665         if (ndr_flags & NDR_SCALARS) {
11666                 NDR_CHECK(ndr_pull_align(ndr, 5));
11667                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11668                 {
11669                         uint32_t _flags_save_string = ndr->flags;
11670                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11671                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11672                         if (_ptr_driver_name) {
11673                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11674                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11675                         } else {
11676                                 r->driver_name = NULL;
11677                         }
11678                         ndr->flags = _flags_save_string;
11679                 }
11680                 {
11681                         uint32_t _flags_save_string = ndr->flags;
11682                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11683                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11684                         if (_ptr_architecture) {
11685                                 NDR_PULL_ALLOC(ndr, r->architecture);
11686                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11687                         } else {
11688                                 r->architecture = NULL;
11689                         }
11690                         ndr->flags = _flags_save_string;
11691                 }
11692                 {
11693                         uint32_t _flags_save_string = ndr->flags;
11694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11695                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11696                         if (_ptr_driver_path) {
11697                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11698                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11699                         } else {
11700                                 r->driver_path = NULL;
11701                         }
11702                         ndr->flags = _flags_save_string;
11703                 }
11704                 {
11705                         uint32_t _flags_save_string = ndr->flags;
11706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11707                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11708                         if (_ptr_data_file) {
11709                                 NDR_PULL_ALLOC(ndr, r->data_file);
11710                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11711                         } else {
11712                                 r->data_file = NULL;
11713                         }
11714                         ndr->flags = _flags_save_string;
11715                 }
11716                 {
11717                         uint32_t _flags_save_string = ndr->flags;
11718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11719                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11720                         if (_ptr_config_file) {
11721                                 NDR_PULL_ALLOC(ndr, r->config_file);
11722                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11723                         } else {
11724                                 r->config_file = NULL;
11725                         }
11726                         ndr->flags = _flags_save_string;
11727                 }
11728                 {
11729                         uint32_t _flags_save_string = ndr->flags;
11730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11731                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11732                         if (_ptr_help_file) {
11733                                 NDR_PULL_ALLOC(ndr, r->help_file);
11734                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11735                         } else {
11736                                 r->help_file = NULL;
11737                         }
11738                         ndr->flags = _flags_save_string;
11739                 }
11740                 {
11741                         uint32_t _flags_save_string_array = ndr->flags;
11742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11743                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11744                         if (_ptr_dependent_files) {
11745                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11746                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11747                         } else {
11748                                 r->dependent_files = NULL;
11749                         }
11750                         ndr->flags = _flags_save_string_array;
11751                 }
11752                 {
11753                         uint32_t _flags_save_string = ndr->flags;
11754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11755                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11756                         if (_ptr_monitor_name) {
11757                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11758                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11759                         } else {
11760                                 r->monitor_name = NULL;
11761                         }
11762                         ndr->flags = _flags_save_string;
11763                 }
11764                 {
11765                         uint32_t _flags_save_string = ndr->flags;
11766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11767                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11768                         if (_ptr_default_datatype) {
11769                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11770                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11771                         } else {
11772                                 r->default_datatype = NULL;
11773                         }
11774                         ndr->flags = _flags_save_string;
11775                 }
11776                 {
11777                         uint32_t _flags_save_string_array = ndr->flags;
11778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11779                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11780                         if (_ptr_previous_names) {
11781                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11782                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11783                         } else {
11784                                 r->previous_names = NULL;
11785                         }
11786                         ndr->flags = _flags_save_string_array;
11787                 }
11788                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11789         }
11790         if (ndr_flags & NDR_BUFFERS) {
11791                 {
11792                         uint32_t _flags_save_string = ndr->flags;
11793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11794                         if (r->driver_name) {
11795                                 uint32_t _relative_save_offset;
11796                                 _relative_save_offset = ndr->offset;
11797                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11798                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11799                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11800                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11801                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11802                                 if (ndr->offset > ndr->relative_highest_offset) {
11803                                         ndr->relative_highest_offset = ndr->offset;
11804                                 }
11805                                 ndr->offset = _relative_save_offset;
11806                         }
11807                         ndr->flags = _flags_save_string;
11808                 }
11809                 {
11810                         uint32_t _flags_save_string = ndr->flags;
11811                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11812                         if (r->architecture) {
11813                                 uint32_t _relative_save_offset;
11814                                 _relative_save_offset = ndr->offset;
11815                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11816                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11817                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11818                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11819                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11820                                 if (ndr->offset > ndr->relative_highest_offset) {
11821                                         ndr->relative_highest_offset = ndr->offset;
11822                                 }
11823                                 ndr->offset = _relative_save_offset;
11824                         }
11825                         ndr->flags = _flags_save_string;
11826                 }
11827                 {
11828                         uint32_t _flags_save_string = ndr->flags;
11829                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11830                         if (r->driver_path) {
11831                                 uint32_t _relative_save_offset;
11832                                 _relative_save_offset = ndr->offset;
11833                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11834                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11835                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11836                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11837                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11838                                 if (ndr->offset > ndr->relative_highest_offset) {
11839                                         ndr->relative_highest_offset = ndr->offset;
11840                                 }
11841                                 ndr->offset = _relative_save_offset;
11842                         }
11843                         ndr->flags = _flags_save_string;
11844                 }
11845                 {
11846                         uint32_t _flags_save_string = ndr->flags;
11847                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11848                         if (r->data_file) {
11849                                 uint32_t _relative_save_offset;
11850                                 _relative_save_offset = ndr->offset;
11851                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11852                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11853                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11854                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11855                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11856                                 if (ndr->offset > ndr->relative_highest_offset) {
11857                                         ndr->relative_highest_offset = ndr->offset;
11858                                 }
11859                                 ndr->offset = _relative_save_offset;
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->config_file) {
11867                                 uint32_t _relative_save_offset;
11868                                 _relative_save_offset = ndr->offset;
11869                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11870                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11871                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11872                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11873                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11874                                 if (ndr->offset > ndr->relative_highest_offset) {
11875                                         ndr->relative_highest_offset = ndr->offset;
11876                                 }
11877                                 ndr->offset = _relative_save_offset;
11878                         }
11879                         ndr->flags = _flags_save_string;
11880                 }
11881                 {
11882                         uint32_t _flags_save_string = ndr->flags;
11883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11884                         if (r->help_file) {
11885                                 uint32_t _relative_save_offset;
11886                                 _relative_save_offset = ndr->offset;
11887                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11888                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11889                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11890                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11891                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11892                                 if (ndr->offset > ndr->relative_highest_offset) {
11893                                         ndr->relative_highest_offset = ndr->offset;
11894                                 }
11895                                 ndr->offset = _relative_save_offset;
11896                         }
11897                         ndr->flags = _flags_save_string;
11898                 }
11899                 {
11900                         uint32_t _flags_save_string_array = ndr->flags;
11901                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11902                         if (r->dependent_files) {
11903                                 uint32_t _relative_save_offset;
11904                                 _relative_save_offset = ndr->offset;
11905                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11906                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11907                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11908                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11909                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11910                                 if (ndr->offset > ndr->relative_highest_offset) {
11911                                         ndr->relative_highest_offset = ndr->offset;
11912                                 }
11913                                 ndr->offset = _relative_save_offset;
11914                         }
11915                         ndr->flags = _flags_save_string_array;
11916                 }
11917                 {
11918                         uint32_t _flags_save_string = ndr->flags;
11919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11920                         if (r->monitor_name) {
11921                                 uint32_t _relative_save_offset;
11922                                 _relative_save_offset = ndr->offset;
11923                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11924                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11925                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11926                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11927                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11928                                 if (ndr->offset > ndr->relative_highest_offset) {
11929                                         ndr->relative_highest_offset = ndr->offset;
11930                                 }
11931                                 ndr->offset = _relative_save_offset;
11932                         }
11933                         ndr->flags = _flags_save_string;
11934                 }
11935                 {
11936                         uint32_t _flags_save_string = ndr->flags;
11937                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11938                         if (r->default_datatype) {
11939                                 uint32_t _relative_save_offset;
11940                                 _relative_save_offset = ndr->offset;
11941                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11942                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11943                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11944                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11945                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11946                                 if (ndr->offset > ndr->relative_highest_offset) {
11947                                         ndr->relative_highest_offset = ndr->offset;
11948                                 }
11949                                 ndr->offset = _relative_save_offset;
11950                         }
11951                         ndr->flags = _flags_save_string;
11952                 }
11953                 {
11954                         uint32_t _flags_save_string_array = ndr->flags;
11955                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11956                         if (r->previous_names) {
11957                                 uint32_t _relative_save_offset;
11958                                 _relative_save_offset = ndr->offset;
11959                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11960                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11961                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11962                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11963                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11964                                 if (ndr->offset > ndr->relative_highest_offset) {
11965                                         ndr->relative_highest_offset = ndr->offset;
11966                                 }
11967                                 ndr->offset = _relative_save_offset;
11968                         }
11969                         ndr->flags = _flags_save_string_array;
11970                 }
11971         }
11972         return NDR_ERR_SUCCESS;
11973 }
11974
11975 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11976 {
11977         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11978         ndr->depth++;
11979         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11980         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11981         ndr->depth++;
11982         if (r->driver_name) {
11983                 ndr_print_string(ndr, "driver_name", r->driver_name);
11984         }
11985         ndr->depth--;
11986         ndr_print_ptr(ndr, "architecture", r->architecture);
11987         ndr->depth++;
11988         if (r->architecture) {
11989                 ndr_print_string(ndr, "architecture", r->architecture);
11990         }
11991         ndr->depth--;
11992         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11993         ndr->depth++;
11994         if (r->driver_path) {
11995                 ndr_print_string(ndr, "driver_path", r->driver_path);
11996         }
11997         ndr->depth--;
11998         ndr_print_ptr(ndr, "data_file", r->data_file);
11999         ndr->depth++;
12000         if (r->data_file) {
12001                 ndr_print_string(ndr, "data_file", r->data_file);
12002         }
12003         ndr->depth--;
12004         ndr_print_ptr(ndr, "config_file", r->config_file);
12005         ndr->depth++;
12006         if (r->config_file) {
12007                 ndr_print_string(ndr, "config_file", r->config_file);
12008         }
12009         ndr->depth--;
12010         ndr_print_ptr(ndr, "help_file", r->help_file);
12011         ndr->depth++;
12012         if (r->help_file) {
12013                 ndr_print_string(ndr, "help_file", r->help_file);
12014         }
12015         ndr->depth--;
12016         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12017         ndr->depth++;
12018         if (r->dependent_files) {
12019                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12020         }
12021         ndr->depth--;
12022         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12023         ndr->depth++;
12024         if (r->monitor_name) {
12025                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12026         }
12027         ndr->depth--;
12028         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12029         ndr->depth++;
12030         if (r->default_datatype) {
12031                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12032         }
12033         ndr->depth--;
12034         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12035         ndr->depth++;
12036         if (r->previous_names) {
12037                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12038         }
12039         ndr->depth--;
12040         ndr->depth--;
12041 }
12042
12043 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
12044 {
12045         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
12046 }
12047
12048 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
12049 {
12050         if (ndr_flags & NDR_SCALARS) {
12051                 NDR_CHECK(ndr_push_align(ndr, 5));
12052                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12053                 {
12054                         uint32_t _flags_save_string = ndr->flags;
12055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12056                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12057                         ndr->flags = _flags_save_string;
12058                 }
12059                 {
12060                         uint32_t _flags_save_string = ndr->flags;
12061                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12062                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12063                         ndr->flags = _flags_save_string;
12064                 }
12065                 {
12066                         uint32_t _flags_save_string = ndr->flags;
12067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12068                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12069                         ndr->flags = _flags_save_string;
12070                 }
12071                 {
12072                         uint32_t _flags_save_string = ndr->flags;
12073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12074                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12075                         ndr->flags = _flags_save_string;
12076                 }
12077                 {
12078                         uint32_t _flags_save_string = ndr->flags;
12079                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12080                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12081                         ndr->flags = _flags_save_string;
12082                 }
12083                 NDR_CHECK(ndr_push_spoolss_DriverAttributes(ndr, NDR_SCALARS, r->driver_attributes));
12084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
12085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
12086                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12087         }
12088         if (ndr_flags & NDR_BUFFERS) {
12089                 {
12090                         uint32_t _flags_save_string = ndr->flags;
12091                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12092                         if (r->driver_name) {
12093                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12094                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12095                         }
12096                         ndr->flags = _flags_save_string;
12097                 }
12098                 {
12099                         uint32_t _flags_save_string = ndr->flags;
12100                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12101                         if (r->architecture) {
12102                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12103                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12104                         }
12105                         ndr->flags = _flags_save_string;
12106                 }
12107                 {
12108                         uint32_t _flags_save_string = ndr->flags;
12109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12110                         if (r->driver_path) {
12111                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12112                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12113                         }
12114                         ndr->flags = _flags_save_string;
12115                 }
12116                 {
12117                         uint32_t _flags_save_string = ndr->flags;
12118                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12119                         if (r->data_file) {
12120                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12121                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12122                         }
12123                         ndr->flags = _flags_save_string;
12124                 }
12125                 {
12126                         uint32_t _flags_save_string = ndr->flags;
12127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12128                         if (r->config_file) {
12129                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12130                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12131                         }
12132                         ndr->flags = _flags_save_string;
12133                 }
12134         }
12135         return NDR_ERR_SUCCESS;
12136 }
12137
12138 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
12139 {
12140         uint32_t _ptr_driver_name;
12141         TALLOC_CTX *_mem_save_driver_name_0;
12142         uint32_t _ptr_architecture;
12143         TALLOC_CTX *_mem_save_architecture_0;
12144         uint32_t _ptr_driver_path;
12145         TALLOC_CTX *_mem_save_driver_path_0;
12146         uint32_t _ptr_data_file;
12147         TALLOC_CTX *_mem_save_data_file_0;
12148         uint32_t _ptr_config_file;
12149         TALLOC_CTX *_mem_save_config_file_0;
12150         if (ndr_flags & NDR_SCALARS) {
12151                 NDR_CHECK(ndr_pull_align(ndr, 5));
12152                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12153                 {
12154                         uint32_t _flags_save_string = ndr->flags;
12155                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12156                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12157                         if (_ptr_driver_name) {
12158                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12159                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12160                         } else {
12161                                 r->driver_name = NULL;
12162                         }
12163                         ndr->flags = _flags_save_string;
12164                 }
12165                 {
12166                         uint32_t _flags_save_string = ndr->flags;
12167                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12168                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12169                         if (_ptr_architecture) {
12170                                 NDR_PULL_ALLOC(ndr, r->architecture);
12171                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12172                         } else {
12173                                 r->architecture = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12181                         if (_ptr_driver_path) {
12182                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12183                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12184                         } else {
12185                                 r->driver_path = NULL;
12186                         }
12187                         ndr->flags = _flags_save_string;
12188                 }
12189                 {
12190                         uint32_t _flags_save_string = ndr->flags;
12191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12192                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12193                         if (_ptr_data_file) {
12194                                 NDR_PULL_ALLOC(ndr, r->data_file);
12195                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12196                         } else {
12197                                 r->data_file = NULL;
12198                         }
12199                         ndr->flags = _flags_save_string;
12200                 }
12201                 {
12202                         uint32_t _flags_save_string = ndr->flags;
12203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12204                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12205                         if (_ptr_config_file) {
12206                                 NDR_PULL_ALLOC(ndr, r->config_file);
12207                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12208                         } else {
12209                                 r->config_file = NULL;
12210                         }
12211                         ndr->flags = _flags_save_string;
12212                 }
12213                 NDR_CHECK(ndr_pull_spoolss_DriverAttributes(ndr, NDR_SCALARS, &r->driver_attributes));
12214                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
12215                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
12216                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12217         }
12218         if (ndr_flags & NDR_BUFFERS) {
12219                 {
12220                         uint32_t _flags_save_string = ndr->flags;
12221                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12222                         if (r->driver_name) {
12223                                 uint32_t _relative_save_offset;
12224                                 _relative_save_offset = ndr->offset;
12225                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12226                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12227                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12228                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12229                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12230                                 if (ndr->offset > ndr->relative_highest_offset) {
12231                                         ndr->relative_highest_offset = ndr->offset;
12232                                 }
12233                                 ndr->offset = _relative_save_offset;
12234                         }
12235                         ndr->flags = _flags_save_string;
12236                 }
12237                 {
12238                         uint32_t _flags_save_string = ndr->flags;
12239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12240                         if (r->architecture) {
12241                                 uint32_t _relative_save_offset;
12242                                 _relative_save_offset = ndr->offset;
12243                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12244                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12245                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12246                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12247                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12248                                 if (ndr->offset > ndr->relative_highest_offset) {
12249                                         ndr->relative_highest_offset = ndr->offset;
12250                                 }
12251                                 ndr->offset = _relative_save_offset;
12252                         }
12253                         ndr->flags = _flags_save_string;
12254                 }
12255                 {
12256                         uint32_t _flags_save_string = ndr->flags;
12257                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12258                         if (r->driver_path) {
12259                                 uint32_t _relative_save_offset;
12260                                 _relative_save_offset = ndr->offset;
12261                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12262                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12263                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12264                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12265                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12266                                 if (ndr->offset > ndr->relative_highest_offset) {
12267                                         ndr->relative_highest_offset = ndr->offset;
12268                                 }
12269                                 ndr->offset = _relative_save_offset;
12270                         }
12271                         ndr->flags = _flags_save_string;
12272                 }
12273                 {
12274                         uint32_t _flags_save_string = ndr->flags;
12275                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12276                         if (r->data_file) {
12277                                 uint32_t _relative_save_offset;
12278                                 _relative_save_offset = ndr->offset;
12279                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12280                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12281                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12282                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12283                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12284                                 if (ndr->offset > ndr->relative_highest_offset) {
12285                                         ndr->relative_highest_offset = ndr->offset;
12286                                 }
12287                                 ndr->offset = _relative_save_offset;
12288                         }
12289                         ndr->flags = _flags_save_string;
12290                 }
12291                 {
12292                         uint32_t _flags_save_string = ndr->flags;
12293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12294                         if (r->config_file) {
12295                                 uint32_t _relative_save_offset;
12296                                 _relative_save_offset = ndr->offset;
12297                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12298                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12299                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12300                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12301                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12302                                 if (ndr->offset > ndr->relative_highest_offset) {
12303                                         ndr->relative_highest_offset = ndr->offset;
12304                                 }
12305                                 ndr->offset = _relative_save_offset;
12306                         }
12307                         ndr->flags = _flags_save_string;
12308                 }
12309         }
12310         return NDR_ERR_SUCCESS;
12311 }
12312
12313 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
12314 {
12315         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
12316         ndr->depth++;
12317         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12318         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12319         ndr->depth++;
12320         if (r->driver_name) {
12321                 ndr_print_string(ndr, "driver_name", r->driver_name);
12322         }
12323         ndr->depth--;
12324         ndr_print_ptr(ndr, "architecture", r->architecture);
12325         ndr->depth++;
12326         if (r->architecture) {
12327                 ndr_print_string(ndr, "architecture", r->architecture);
12328         }
12329         ndr->depth--;
12330         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12331         ndr->depth++;
12332         if (r->driver_path) {
12333                 ndr_print_string(ndr, "driver_path", r->driver_path);
12334         }
12335         ndr->depth--;
12336         ndr_print_ptr(ndr, "data_file", r->data_file);
12337         ndr->depth++;
12338         if (r->data_file) {
12339                 ndr_print_string(ndr, "data_file", r->data_file);
12340         }
12341         ndr->depth--;
12342         ndr_print_ptr(ndr, "config_file", r->config_file);
12343         ndr->depth++;
12344         if (r->config_file) {
12345                 ndr_print_string(ndr, "config_file", r->config_file);
12346         }
12347         ndr->depth--;
12348         ndr_print_spoolss_DriverAttributes(ndr, "driver_attributes", r->driver_attributes);
12349         ndr_print_uint32(ndr, "config_version", r->config_version);
12350         ndr_print_uint32(ndr, "driver_version", r->driver_version);
12351         ndr->depth--;
12352 }
12353
12354 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
12355 {
12356         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
12357 }
12358
12359 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
12360 {
12361         if (ndr_flags & NDR_SCALARS) {
12362                 NDR_CHECK(ndr_push_align(ndr, 8));
12363                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12364                 {
12365                         uint32_t _flags_save_string = ndr->flags;
12366                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12367                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12368                         ndr->flags = _flags_save_string;
12369                 }
12370                 {
12371                         uint32_t _flags_save_string = ndr->flags;
12372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12373                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12374                         ndr->flags = _flags_save_string;
12375                 }
12376                 {
12377                         uint32_t _flags_save_string = ndr->flags;
12378                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12379                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12380                         ndr->flags = _flags_save_string;
12381                 }
12382                 {
12383                         uint32_t _flags_save_string = ndr->flags;
12384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12385                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12386                         ndr->flags = _flags_save_string;
12387                 }
12388                 {
12389                         uint32_t _flags_save_string = ndr->flags;
12390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12391                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12392                         ndr->flags = _flags_save_string;
12393                 }
12394                 {
12395                         uint32_t _flags_save_string = ndr->flags;
12396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12397                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12398                         ndr->flags = _flags_save_string;
12399                 }
12400                 {
12401                         uint32_t _flags_save_string_array = ndr->flags;
12402                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12403                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12404                         ndr->flags = _flags_save_string_array;
12405                 }
12406                 {
12407                         uint32_t _flags_save_string = ndr->flags;
12408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12409                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12410                         ndr->flags = _flags_save_string;
12411                 }
12412                 {
12413                         uint32_t _flags_save_string = ndr->flags;
12414                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12415                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12416                         ndr->flags = _flags_save_string;
12417                 }
12418                 {
12419                         uint32_t _flags_save_string_array = ndr->flags;
12420                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12421                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12422                         ndr->flags = _flags_save_string_array;
12423                 }
12424                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12425                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12426                 {
12427                         uint32_t _flags_save_string = ndr->flags;
12428                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12429                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12430                         ndr->flags = _flags_save_string;
12431                 }
12432                 {
12433                         uint32_t _flags_save_string = ndr->flags;
12434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12435                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12436                         ndr->flags = _flags_save_string;
12437                 }
12438                 {
12439                         uint32_t _flags_save_string = ndr->flags;
12440                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12441                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12442                         ndr->flags = _flags_save_string;
12443                 }
12444                 {
12445                         uint32_t _flags_save_string = ndr->flags;
12446                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12447                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12448                         ndr->flags = _flags_save_string;
12449                 }
12450                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12451         }
12452         if (ndr_flags & NDR_BUFFERS) {
12453                 {
12454                         uint32_t _flags_save_string = ndr->flags;
12455                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12456                         if (r->driver_name) {
12457                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12458                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12459                         }
12460                         ndr->flags = _flags_save_string;
12461                 }
12462                 {
12463                         uint32_t _flags_save_string = ndr->flags;
12464                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12465                         if (r->architecture) {
12466                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12467                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12468                         }
12469                         ndr->flags = _flags_save_string;
12470                 }
12471                 {
12472                         uint32_t _flags_save_string = ndr->flags;
12473                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12474                         if (r->driver_path) {
12475                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12476                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12477                         }
12478                         ndr->flags = _flags_save_string;
12479                 }
12480                 {
12481                         uint32_t _flags_save_string = ndr->flags;
12482                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12483                         if (r->data_file) {
12484                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12485                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12486                         }
12487                         ndr->flags = _flags_save_string;
12488                 }
12489                 {
12490                         uint32_t _flags_save_string = ndr->flags;
12491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12492                         if (r->config_file) {
12493                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12494                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12495                         }
12496                         ndr->flags = _flags_save_string;
12497                 }
12498                 {
12499                         uint32_t _flags_save_string = ndr->flags;
12500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12501                         if (r->help_file) {
12502                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12503                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12504                         }
12505                         ndr->flags = _flags_save_string;
12506                 }
12507                 {
12508                         uint32_t _flags_save_string_array = ndr->flags;
12509                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12510                         if (r->dependent_files) {
12511                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12512                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12513                         }
12514                         ndr->flags = _flags_save_string_array;
12515                 }
12516                 {
12517                         uint32_t _flags_save_string = ndr->flags;
12518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12519                         if (r->monitor_name) {
12520                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12521                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12522                         }
12523                         ndr->flags = _flags_save_string;
12524                 }
12525                 {
12526                         uint32_t _flags_save_string = ndr->flags;
12527                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12528                         if (r->default_datatype) {
12529                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12530                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12531                         }
12532                         ndr->flags = _flags_save_string;
12533                 }
12534                 {
12535                         uint32_t _flags_save_string_array = ndr->flags;
12536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12537                         if (r->previous_names) {
12538                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12539                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12540                         }
12541                         ndr->flags = _flags_save_string_array;
12542                 }
12543                 {
12544                         uint32_t _flags_save_string = ndr->flags;
12545                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12546                         if (r->manufacturer_name) {
12547                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12548                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12549                         }
12550                         ndr->flags = _flags_save_string;
12551                 }
12552                 {
12553                         uint32_t _flags_save_string = ndr->flags;
12554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12555                         if (r->manufacturer_url) {
12556                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12557                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12558                         }
12559                         ndr->flags = _flags_save_string;
12560                 }
12561                 {
12562                         uint32_t _flags_save_string = ndr->flags;
12563                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12564                         if (r->hardware_id) {
12565                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12566                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12567                         }
12568                         ndr->flags = _flags_save_string;
12569                 }
12570                 {
12571                         uint32_t _flags_save_string = ndr->flags;
12572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12573                         if (r->provider) {
12574                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12575                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12576                         }
12577                         ndr->flags = _flags_save_string;
12578                 }
12579         }
12580         return NDR_ERR_SUCCESS;
12581 }
12582
12583 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
12584 {
12585         uint32_t _ptr_driver_name;
12586         TALLOC_CTX *_mem_save_driver_name_0;
12587         uint32_t _ptr_architecture;
12588         TALLOC_CTX *_mem_save_architecture_0;
12589         uint32_t _ptr_driver_path;
12590         TALLOC_CTX *_mem_save_driver_path_0;
12591         uint32_t _ptr_data_file;
12592         TALLOC_CTX *_mem_save_data_file_0;
12593         uint32_t _ptr_config_file;
12594         TALLOC_CTX *_mem_save_config_file_0;
12595         uint32_t _ptr_help_file;
12596         TALLOC_CTX *_mem_save_help_file_0;
12597         uint32_t _ptr_dependent_files;
12598         TALLOC_CTX *_mem_save_dependent_files_0;
12599         uint32_t _ptr_monitor_name;
12600         TALLOC_CTX *_mem_save_monitor_name_0;
12601         uint32_t _ptr_default_datatype;
12602         TALLOC_CTX *_mem_save_default_datatype_0;
12603         uint32_t _ptr_previous_names;
12604         TALLOC_CTX *_mem_save_previous_names_0;
12605         uint32_t _ptr_manufacturer_name;
12606         TALLOC_CTX *_mem_save_manufacturer_name_0;
12607         uint32_t _ptr_manufacturer_url;
12608         TALLOC_CTX *_mem_save_manufacturer_url_0;
12609         uint32_t _ptr_hardware_id;
12610         TALLOC_CTX *_mem_save_hardware_id_0;
12611         uint32_t _ptr_provider;
12612         TALLOC_CTX *_mem_save_provider_0;
12613         if (ndr_flags & NDR_SCALARS) {
12614                 NDR_CHECK(ndr_pull_align(ndr, 8));
12615                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12616                 {
12617                         uint32_t _flags_save_string = ndr->flags;
12618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12619                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12620                         if (_ptr_driver_name) {
12621                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12622                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12623                         } else {
12624                                 r->driver_name = NULL;
12625                         }
12626                         ndr->flags = _flags_save_string;
12627                 }
12628                 {
12629                         uint32_t _flags_save_string = ndr->flags;
12630                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12631                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12632                         if (_ptr_architecture) {
12633                                 NDR_PULL_ALLOC(ndr, r->architecture);
12634                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12635                         } else {
12636                                 r->architecture = NULL;
12637                         }
12638                         ndr->flags = _flags_save_string;
12639                 }
12640                 {
12641                         uint32_t _flags_save_string = ndr->flags;
12642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12643                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12644                         if (_ptr_driver_path) {
12645                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12646                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12647                         } else {
12648                                 r->driver_path = NULL;
12649                         }
12650                         ndr->flags = _flags_save_string;
12651                 }
12652                 {
12653                         uint32_t _flags_save_string = ndr->flags;
12654                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12655                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12656                         if (_ptr_data_file) {
12657                                 NDR_PULL_ALLOC(ndr, r->data_file);
12658                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12659                         } else {
12660                                 r->data_file = NULL;
12661                         }
12662                         ndr->flags = _flags_save_string;
12663                 }
12664                 {
12665                         uint32_t _flags_save_string = ndr->flags;
12666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12667                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12668                         if (_ptr_config_file) {
12669                                 NDR_PULL_ALLOC(ndr, r->config_file);
12670                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12671                         } else {
12672                                 r->config_file = NULL;
12673                         }
12674                         ndr->flags = _flags_save_string;
12675                 }
12676                 {
12677                         uint32_t _flags_save_string = ndr->flags;
12678                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12679                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12680                         if (_ptr_help_file) {
12681                                 NDR_PULL_ALLOC(ndr, r->help_file);
12682                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12683                         } else {
12684                                 r->help_file = NULL;
12685                         }
12686                         ndr->flags = _flags_save_string;
12687                 }
12688                 {
12689                         uint32_t _flags_save_string_array = ndr->flags;
12690                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12691                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12692                         if (_ptr_dependent_files) {
12693                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12694                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12695                         } else {
12696                                 r->dependent_files = NULL;
12697                         }
12698                         ndr->flags = _flags_save_string_array;
12699                 }
12700                 {
12701                         uint32_t _flags_save_string = ndr->flags;
12702                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12703                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12704                         if (_ptr_monitor_name) {
12705                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12706                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12707                         } else {
12708                                 r->monitor_name = NULL;
12709                         }
12710                         ndr->flags = _flags_save_string;
12711                 }
12712                 {
12713                         uint32_t _flags_save_string = ndr->flags;
12714                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12715                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12716                         if (_ptr_default_datatype) {
12717                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12718                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12719                         } else {
12720                                 r->default_datatype = NULL;
12721                         }
12722                         ndr->flags = _flags_save_string;
12723                 }
12724                 {
12725                         uint32_t _flags_save_string_array = ndr->flags;
12726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12727                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12728                         if (_ptr_previous_names) {
12729                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12730                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12731                         } else {
12732                                 r->previous_names = NULL;
12733                         }
12734                         ndr->flags = _flags_save_string_array;
12735                 }
12736                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12737                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12738                 {
12739                         uint32_t _flags_save_string = ndr->flags;
12740                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12741                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12742                         if (_ptr_manufacturer_name) {
12743                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12744                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12745                         } else {
12746                                 r->manufacturer_name = NULL;
12747                         }
12748                         ndr->flags = _flags_save_string;
12749                 }
12750                 {
12751                         uint32_t _flags_save_string = ndr->flags;
12752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12753                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12754                         if (_ptr_manufacturer_url) {
12755                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12756                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12757                         } else {
12758                                 r->manufacturer_url = NULL;
12759                         }
12760                         ndr->flags = _flags_save_string;
12761                 }
12762                 {
12763                         uint32_t _flags_save_string = ndr->flags;
12764                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12765                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12766                         if (_ptr_hardware_id) {
12767                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12768                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12769                         } else {
12770                                 r->hardware_id = NULL;
12771                         }
12772                         ndr->flags = _flags_save_string;
12773                 }
12774                 {
12775                         uint32_t _flags_save_string = ndr->flags;
12776                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12777                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12778                         if (_ptr_provider) {
12779                                 NDR_PULL_ALLOC(ndr, r->provider);
12780                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12781                         } else {
12782                                 r->provider = NULL;
12783                         }
12784                         ndr->flags = _flags_save_string;
12785                 }
12786                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12787         }
12788         if (ndr_flags & NDR_BUFFERS) {
12789                 {
12790                         uint32_t _flags_save_string = ndr->flags;
12791                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12792                         if (r->driver_name) {
12793                                 uint32_t _relative_save_offset;
12794                                 _relative_save_offset = ndr->offset;
12795                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12796                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12797                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12798                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12799                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12800                                 if (ndr->offset > ndr->relative_highest_offset) {
12801                                         ndr->relative_highest_offset = ndr->offset;
12802                                 }
12803                                 ndr->offset = _relative_save_offset;
12804                         }
12805                         ndr->flags = _flags_save_string;
12806                 }
12807                 {
12808                         uint32_t _flags_save_string = ndr->flags;
12809                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12810                         if (r->architecture) {
12811                                 uint32_t _relative_save_offset;
12812                                 _relative_save_offset = ndr->offset;
12813                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12814                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12815                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12816                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12817                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12818                                 if (ndr->offset > ndr->relative_highest_offset) {
12819                                         ndr->relative_highest_offset = ndr->offset;
12820                                 }
12821                                 ndr->offset = _relative_save_offset;
12822                         }
12823                         ndr->flags = _flags_save_string;
12824                 }
12825                 {
12826                         uint32_t _flags_save_string = ndr->flags;
12827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12828                         if (r->driver_path) {
12829                                 uint32_t _relative_save_offset;
12830                                 _relative_save_offset = ndr->offset;
12831                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12832                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12833                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12834                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12835                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12836                                 if (ndr->offset > ndr->relative_highest_offset) {
12837                                         ndr->relative_highest_offset = ndr->offset;
12838                                 }
12839                                 ndr->offset = _relative_save_offset;
12840                         }
12841                         ndr->flags = _flags_save_string;
12842                 }
12843                 {
12844                         uint32_t _flags_save_string = ndr->flags;
12845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12846                         if (r->data_file) {
12847                                 uint32_t _relative_save_offset;
12848                                 _relative_save_offset = ndr->offset;
12849                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12850                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12851                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12852                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12853                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12854                                 if (ndr->offset > ndr->relative_highest_offset) {
12855                                         ndr->relative_highest_offset = ndr->offset;
12856                                 }
12857                                 ndr->offset = _relative_save_offset;
12858                         }
12859                         ndr->flags = _flags_save_string;
12860                 }
12861                 {
12862                         uint32_t _flags_save_string = ndr->flags;
12863                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12864                         if (r->config_file) {
12865                                 uint32_t _relative_save_offset;
12866                                 _relative_save_offset = ndr->offset;
12867                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12868                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12869                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12870                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12871                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12872                                 if (ndr->offset > ndr->relative_highest_offset) {
12873                                         ndr->relative_highest_offset = ndr->offset;
12874                                 }
12875                                 ndr->offset = _relative_save_offset;
12876                         }
12877                         ndr->flags = _flags_save_string;
12878                 }
12879                 {
12880                         uint32_t _flags_save_string = ndr->flags;
12881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12882                         if (r->help_file) {
12883                                 uint32_t _relative_save_offset;
12884                                 _relative_save_offset = ndr->offset;
12885                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12886                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12887                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12888                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12889                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12890                                 if (ndr->offset > ndr->relative_highest_offset) {
12891                                         ndr->relative_highest_offset = ndr->offset;
12892                                 }
12893                                 ndr->offset = _relative_save_offset;
12894                         }
12895                         ndr->flags = _flags_save_string;
12896                 }
12897                 {
12898                         uint32_t _flags_save_string_array = ndr->flags;
12899                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12900                         if (r->dependent_files) {
12901                                 uint32_t _relative_save_offset;
12902                                 _relative_save_offset = ndr->offset;
12903                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12904                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12905                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12906                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12907                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12908                                 if (ndr->offset > ndr->relative_highest_offset) {
12909                                         ndr->relative_highest_offset = ndr->offset;
12910                                 }
12911                                 ndr->offset = _relative_save_offset;
12912                         }
12913                         ndr->flags = _flags_save_string_array;
12914                 }
12915                 {
12916                         uint32_t _flags_save_string = ndr->flags;
12917                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12918                         if (r->monitor_name) {
12919                                 uint32_t _relative_save_offset;
12920                                 _relative_save_offset = ndr->offset;
12921                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12922                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12923                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12924                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12925                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12926                                 if (ndr->offset > ndr->relative_highest_offset) {
12927                                         ndr->relative_highest_offset = ndr->offset;
12928                                 }
12929                                 ndr->offset = _relative_save_offset;
12930                         }
12931                         ndr->flags = _flags_save_string;
12932                 }
12933                 {
12934                         uint32_t _flags_save_string = ndr->flags;
12935                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12936                         if (r->default_datatype) {
12937                                 uint32_t _relative_save_offset;
12938                                 _relative_save_offset = ndr->offset;
12939                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12940                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12941                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12942                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12943                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12944                                 if (ndr->offset > ndr->relative_highest_offset) {
12945                                         ndr->relative_highest_offset = ndr->offset;
12946                                 }
12947                                 ndr->offset = _relative_save_offset;
12948                         }
12949                         ndr->flags = _flags_save_string;
12950                 }
12951                 {
12952                         uint32_t _flags_save_string_array = ndr->flags;
12953                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12954                         if (r->previous_names) {
12955                                 uint32_t _relative_save_offset;
12956                                 _relative_save_offset = ndr->offset;
12957                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12958                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12959                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12960                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12961                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12962                                 if (ndr->offset > ndr->relative_highest_offset) {
12963                                         ndr->relative_highest_offset = ndr->offset;
12964                                 }
12965                                 ndr->offset = _relative_save_offset;
12966                         }
12967                         ndr->flags = _flags_save_string_array;
12968                 }
12969                 {
12970                         uint32_t _flags_save_string = ndr->flags;
12971                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12972                         if (r->manufacturer_name) {
12973                                 uint32_t _relative_save_offset;
12974                                 _relative_save_offset = ndr->offset;
12975                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12976                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12977                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12978                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12979                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12980                                 if (ndr->offset > ndr->relative_highest_offset) {
12981                                         ndr->relative_highest_offset = ndr->offset;
12982                                 }
12983                                 ndr->offset = _relative_save_offset;
12984                         }
12985                         ndr->flags = _flags_save_string;
12986                 }
12987                 {
12988                         uint32_t _flags_save_string = ndr->flags;
12989                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12990                         if (r->manufacturer_url) {
12991                                 uint32_t _relative_save_offset;
12992                                 _relative_save_offset = ndr->offset;
12993                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12994                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12995                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12996                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12997                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12998                                 if (ndr->offset > ndr->relative_highest_offset) {
12999                                         ndr->relative_highest_offset = ndr->offset;
13000                                 }
13001                                 ndr->offset = _relative_save_offset;
13002                         }
13003                         ndr->flags = _flags_save_string;
13004                 }
13005                 {
13006                         uint32_t _flags_save_string = ndr->flags;
13007                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13008                         if (r->hardware_id) {
13009                                 uint32_t _relative_save_offset;
13010                                 _relative_save_offset = ndr->offset;
13011                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13012                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13013                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13014                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13015                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13016                                 if (ndr->offset > ndr->relative_highest_offset) {
13017                                         ndr->relative_highest_offset = ndr->offset;
13018                                 }
13019                                 ndr->offset = _relative_save_offset;
13020                         }
13021                         ndr->flags = _flags_save_string;
13022                 }
13023                 {
13024                         uint32_t _flags_save_string = ndr->flags;
13025                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13026                         if (r->provider) {
13027                                 uint32_t _relative_save_offset;
13028                                 _relative_save_offset = ndr->offset;
13029                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13030                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13031                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13032                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13033                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13034                                 if (ndr->offset > ndr->relative_highest_offset) {
13035                                         ndr->relative_highest_offset = ndr->offset;
13036                                 }
13037                                 ndr->offset = _relative_save_offset;
13038                         }
13039                         ndr->flags = _flags_save_string;
13040                 }
13041         }
13042         return NDR_ERR_SUCCESS;
13043 }
13044
13045 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
13046 {
13047         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
13048         ndr->depth++;
13049         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13050         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13051         ndr->depth++;
13052         if (r->driver_name) {
13053                 ndr_print_string(ndr, "driver_name", r->driver_name);
13054         }
13055         ndr->depth--;
13056         ndr_print_ptr(ndr, "architecture", r->architecture);
13057         ndr->depth++;
13058         if (r->architecture) {
13059                 ndr_print_string(ndr, "architecture", r->architecture);
13060         }
13061         ndr->depth--;
13062         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13063         ndr->depth++;
13064         if (r->driver_path) {
13065                 ndr_print_string(ndr, "driver_path", r->driver_path);
13066         }
13067         ndr->depth--;
13068         ndr_print_ptr(ndr, "data_file", r->data_file);
13069         ndr->depth++;
13070         if (r->data_file) {
13071                 ndr_print_string(ndr, "data_file", r->data_file);
13072         }
13073         ndr->depth--;
13074         ndr_print_ptr(ndr, "config_file", r->config_file);
13075         ndr->depth++;
13076         if (r->config_file) {
13077                 ndr_print_string(ndr, "config_file", r->config_file);
13078         }
13079         ndr->depth--;
13080         ndr_print_ptr(ndr, "help_file", r->help_file);
13081         ndr->depth++;
13082         if (r->help_file) {
13083                 ndr_print_string(ndr, "help_file", r->help_file);
13084         }
13085         ndr->depth--;
13086         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13087         ndr->depth++;
13088         if (r->dependent_files) {
13089                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13090         }
13091         ndr->depth--;
13092         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13093         ndr->depth++;
13094         if (r->monitor_name) {
13095                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13096         }
13097         ndr->depth--;
13098         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13099         ndr->depth++;
13100         if (r->default_datatype) {
13101                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13102         }
13103         ndr->depth--;
13104         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13105         ndr->depth++;
13106         if (r->previous_names) {
13107                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13108         }
13109         ndr->depth--;
13110         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13111         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13112         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13113         ndr->depth++;
13114         if (r->manufacturer_name) {
13115                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13116         }
13117         ndr->depth--;
13118         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13119         ndr->depth++;
13120         if (r->manufacturer_url) {
13121                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13122         }
13123         ndr->depth--;
13124         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13125         ndr->depth++;
13126         if (r->hardware_id) {
13127                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13128         }
13129         ndr->depth--;
13130         ndr_print_ptr(ndr, "provider", r->provider);
13131         ndr->depth++;
13132         if (r->provider) {
13133                 ndr_print_string(ndr, "provider", r->provider);
13134         }
13135         ndr->depth--;
13136         ndr->depth--;
13137 }
13138
13139 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
13140 {
13141         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
13142 }
13143
13144 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
13145 {
13146         if (ndr_flags & NDR_SCALARS) {
13147                 NDR_CHECK(ndr_push_align(ndr, 8));
13148                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
13149                 {
13150                         uint32_t _flags_save_string = ndr->flags;
13151                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13152                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
13153                         ndr->flags = _flags_save_string;
13154                 }
13155                 {
13156                         uint32_t _flags_save_string = ndr->flags;
13157                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13158                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
13159                         ndr->flags = _flags_save_string;
13160                 }
13161                 {
13162                         uint32_t _flags_save_string = ndr->flags;
13163                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13164                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
13165                         ndr->flags = _flags_save_string;
13166                 }
13167                 {
13168                         uint32_t _flags_save_string = ndr->flags;
13169                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13170                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
13171                         ndr->flags = _flags_save_string;
13172                 }
13173                 {
13174                         uint32_t _flags_save_string = ndr->flags;
13175                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13176                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
13177                         ndr->flags = _flags_save_string;
13178                 }
13179                 {
13180                         uint32_t _flags_save_string = ndr->flags;
13181                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13182                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
13183                         ndr->flags = _flags_save_string;
13184                 }
13185                 {
13186                         uint32_t _flags_save_string_array = ndr->flags;
13187                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13188                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
13189                         ndr->flags = _flags_save_string_array;
13190                 }
13191                 {
13192                         uint32_t _flags_save_string = ndr->flags;
13193                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13194                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
13195                         ndr->flags = _flags_save_string;
13196                 }
13197                 {
13198                         uint32_t _flags_save_string = ndr->flags;
13199                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13200                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
13201                         ndr->flags = _flags_save_string;
13202                 }
13203                 {
13204                         uint32_t _flags_save_string_array = ndr->flags;
13205                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13206                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
13207                         ndr->flags = _flags_save_string_array;
13208                 }
13209                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
13210                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
13211                 {
13212                         uint32_t _flags_save_string = ndr->flags;
13213                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13214                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
13215                         ndr->flags = _flags_save_string;
13216                 }
13217                 {
13218                         uint32_t _flags_save_string = ndr->flags;
13219                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13220                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
13221                         ndr->flags = _flags_save_string;
13222                 }
13223                 {
13224                         uint32_t _flags_save_string = ndr->flags;
13225                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13226                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
13227                         ndr->flags = _flags_save_string;
13228                 }
13229                 {
13230                         uint32_t _flags_save_string = ndr->flags;
13231                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13232                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
13233                         ndr->flags = _flags_save_string;
13234                 }
13235                 {
13236                         uint32_t _flags_save_string = ndr->flags;
13237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13238                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
13239                         ndr->flags = _flags_save_string;
13240                 }
13241                 {
13242                         uint32_t _flags_save_string = ndr->flags;
13243                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13244                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
13245                         ndr->flags = _flags_save_string;
13246                 }
13247                 {
13248                         uint32_t _flags_save_string_array = ndr->flags;
13249                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13250                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
13251                         ndr->flags = _flags_save_string_array;
13252                 }
13253                 {
13254                         uint32_t _flags_save_string = ndr->flags;
13255                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13256                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
13257                         ndr->flags = _flags_save_string;
13258                 }
13259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
13260                 {
13261                         uint32_t _flags_save_string_array = ndr->flags;
13262                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13263                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
13264                         ndr->flags = _flags_save_string_array;
13265                 }
13266                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
13267                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
13268                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
13269         }
13270         if (ndr_flags & NDR_BUFFERS) {
13271                 {
13272                         uint32_t _flags_save_string = ndr->flags;
13273                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13274                         if (r->driver_name) {
13275                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
13276                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
13277                         }
13278                         ndr->flags = _flags_save_string;
13279                 }
13280                 {
13281                         uint32_t _flags_save_string = ndr->flags;
13282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13283                         if (r->architecture) {
13284                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
13285                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
13286                         }
13287                         ndr->flags = _flags_save_string;
13288                 }
13289                 {
13290                         uint32_t _flags_save_string = ndr->flags;
13291                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13292                         if (r->driver_path) {
13293                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
13294                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
13295                         }
13296                         ndr->flags = _flags_save_string;
13297                 }
13298                 {
13299                         uint32_t _flags_save_string = ndr->flags;
13300                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13301                         if (r->data_file) {
13302                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
13303                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
13304                         }
13305                         ndr->flags = _flags_save_string;
13306                 }
13307                 {
13308                         uint32_t _flags_save_string = ndr->flags;
13309                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13310                         if (r->config_file) {
13311                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
13312                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
13313                         }
13314                         ndr->flags = _flags_save_string;
13315                 }
13316                 {
13317                         uint32_t _flags_save_string = ndr->flags;
13318                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13319                         if (r->help_file) {
13320                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
13321                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
13322                         }
13323                         ndr->flags = _flags_save_string;
13324                 }
13325                 {
13326                         uint32_t _flags_save_string_array = ndr->flags;
13327                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13328                         if (r->dependent_files) {
13329                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
13330                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
13331                         }
13332                         ndr->flags = _flags_save_string_array;
13333                 }
13334                 {
13335                         uint32_t _flags_save_string = ndr->flags;
13336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13337                         if (r->monitor_name) {
13338                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
13339                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
13340                         }
13341                         ndr->flags = _flags_save_string;
13342                 }
13343                 {
13344                         uint32_t _flags_save_string = ndr->flags;
13345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13346                         if (r->default_datatype) {
13347                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
13348                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
13349                         }
13350                         ndr->flags = _flags_save_string;
13351                 }
13352                 {
13353                         uint32_t _flags_save_string_array = ndr->flags;
13354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13355                         if (r->previous_names) {
13356                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
13357                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
13358                         }
13359                         ndr->flags = _flags_save_string_array;
13360                 }
13361                 {
13362                         uint32_t _flags_save_string = ndr->flags;
13363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13364                         if (r->manufacturer_name) {
13365                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
13366                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
13367                         }
13368                         ndr->flags = _flags_save_string;
13369                 }
13370                 {
13371                         uint32_t _flags_save_string = ndr->flags;
13372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13373                         if (r->manufacturer_url) {
13374                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
13375                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
13376                         }
13377                         ndr->flags = _flags_save_string;
13378                 }
13379                 {
13380                         uint32_t _flags_save_string = ndr->flags;
13381                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13382                         if (r->hardware_id) {
13383                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
13384                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
13385                         }
13386                         ndr->flags = _flags_save_string;
13387                 }
13388                 {
13389                         uint32_t _flags_save_string = ndr->flags;
13390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13391                         if (r->provider) {
13392                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
13393                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
13394                         }
13395                         ndr->flags = _flags_save_string;
13396                 }
13397                 {
13398                         uint32_t _flags_save_string = ndr->flags;
13399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13400                         if (r->print_processor) {
13401                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
13402                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
13403                         }
13404                         ndr->flags = _flags_save_string;
13405                 }
13406                 {
13407                         uint32_t _flags_save_string = ndr->flags;
13408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13409                         if (r->vendor_setup) {
13410                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
13411                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
13412                         }
13413                         ndr->flags = _flags_save_string;
13414                 }
13415                 {
13416                         uint32_t _flags_save_string_array = ndr->flags;
13417                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13418                         if (r->color_profiles) {
13419                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
13420                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
13421                         }
13422                         ndr->flags = _flags_save_string_array;
13423                 }
13424                 {
13425                         uint32_t _flags_save_string = ndr->flags;
13426                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13427                         if (r->inf_path) {
13428                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
13429                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
13430                         }
13431                         ndr->flags = _flags_save_string;
13432                 }
13433                 {
13434                         uint32_t _flags_save_string_array = ndr->flags;
13435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13436                         if (r->core_driver_dependencies) {
13437                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
13438                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
13439                         }
13440                         ndr->flags = _flags_save_string_array;
13441                 }
13442         }
13443         return NDR_ERR_SUCCESS;
13444 }
13445
13446 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
13447 {
13448         uint32_t _ptr_driver_name;
13449         TALLOC_CTX *_mem_save_driver_name_0;
13450         uint32_t _ptr_architecture;
13451         TALLOC_CTX *_mem_save_architecture_0;
13452         uint32_t _ptr_driver_path;
13453         TALLOC_CTX *_mem_save_driver_path_0;
13454         uint32_t _ptr_data_file;
13455         TALLOC_CTX *_mem_save_data_file_0;
13456         uint32_t _ptr_config_file;
13457         TALLOC_CTX *_mem_save_config_file_0;
13458         uint32_t _ptr_help_file;
13459         TALLOC_CTX *_mem_save_help_file_0;
13460         uint32_t _ptr_dependent_files;
13461         TALLOC_CTX *_mem_save_dependent_files_0;
13462         uint32_t _ptr_monitor_name;
13463         TALLOC_CTX *_mem_save_monitor_name_0;
13464         uint32_t _ptr_default_datatype;
13465         TALLOC_CTX *_mem_save_default_datatype_0;
13466         uint32_t _ptr_previous_names;
13467         TALLOC_CTX *_mem_save_previous_names_0;
13468         uint32_t _ptr_manufacturer_name;
13469         TALLOC_CTX *_mem_save_manufacturer_name_0;
13470         uint32_t _ptr_manufacturer_url;
13471         TALLOC_CTX *_mem_save_manufacturer_url_0;
13472         uint32_t _ptr_hardware_id;
13473         TALLOC_CTX *_mem_save_hardware_id_0;
13474         uint32_t _ptr_provider;
13475         TALLOC_CTX *_mem_save_provider_0;
13476         uint32_t _ptr_print_processor;
13477         TALLOC_CTX *_mem_save_print_processor_0;
13478         uint32_t _ptr_vendor_setup;
13479         TALLOC_CTX *_mem_save_vendor_setup_0;
13480         uint32_t _ptr_color_profiles;
13481         TALLOC_CTX *_mem_save_color_profiles_0;
13482         uint32_t _ptr_inf_path;
13483         TALLOC_CTX *_mem_save_inf_path_0;
13484         uint32_t _ptr_core_driver_dependencies;
13485         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
13486         if (ndr_flags & NDR_SCALARS) {
13487                 NDR_CHECK(ndr_pull_align(ndr, 8));
13488                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13489                 {
13490                         uint32_t _flags_save_string = ndr->flags;
13491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13492                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13493                         if (_ptr_driver_name) {
13494                                 NDR_PULL_ALLOC(ndr, r->driver_name);
13495                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13496                         } else {
13497                                 r->driver_name = NULL;
13498                         }
13499                         ndr->flags = _flags_save_string;
13500                 }
13501                 {
13502                         uint32_t _flags_save_string = ndr->flags;
13503                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13504                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
13505                         if (_ptr_architecture) {
13506                                 NDR_PULL_ALLOC(ndr, r->architecture);
13507                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
13508                         } else {
13509                                 r->architecture = NULL;
13510                         }
13511                         ndr->flags = _flags_save_string;
13512                 }
13513                 {
13514                         uint32_t _flags_save_string = ndr->flags;
13515                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13516                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
13517                         if (_ptr_driver_path) {
13518                                 NDR_PULL_ALLOC(ndr, r->driver_path);
13519                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
13520                         } else {
13521                                 r->driver_path = NULL;
13522                         }
13523                         ndr->flags = _flags_save_string;
13524                 }
13525                 {
13526                         uint32_t _flags_save_string = ndr->flags;
13527                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13528                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
13529                         if (_ptr_data_file) {
13530                                 NDR_PULL_ALLOC(ndr, r->data_file);
13531                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
13532                         } else {
13533                                 r->data_file = NULL;
13534                         }
13535                         ndr->flags = _flags_save_string;
13536                 }
13537                 {
13538                         uint32_t _flags_save_string = ndr->flags;
13539                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13540                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
13541                         if (_ptr_config_file) {
13542                                 NDR_PULL_ALLOC(ndr, r->config_file);
13543                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
13544                         } else {
13545                                 r->config_file = NULL;
13546                         }
13547                         ndr->flags = _flags_save_string;
13548                 }
13549                 {
13550                         uint32_t _flags_save_string = ndr->flags;
13551                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13552                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
13553                         if (_ptr_help_file) {
13554                                 NDR_PULL_ALLOC(ndr, r->help_file);
13555                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
13556                         } else {
13557                                 r->help_file = NULL;
13558                         }
13559                         ndr->flags = _flags_save_string;
13560                 }
13561                 {
13562                         uint32_t _flags_save_string_array = ndr->flags;
13563                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13564                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
13565                         if (_ptr_dependent_files) {
13566                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
13567                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
13568                         } else {
13569                                 r->dependent_files = NULL;
13570                         }
13571                         ndr->flags = _flags_save_string_array;
13572                 }
13573                 {
13574                         uint32_t _flags_save_string = ndr->flags;
13575                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13576                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
13577                         if (_ptr_monitor_name) {
13578                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
13579                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
13580                         } else {
13581                                 r->monitor_name = NULL;
13582                         }
13583                         ndr->flags = _flags_save_string;
13584                 }
13585                 {
13586                         uint32_t _flags_save_string = ndr->flags;
13587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13588                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
13589                         if (_ptr_default_datatype) {
13590                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
13591                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
13592                         } else {
13593                                 r->default_datatype = NULL;
13594                         }
13595                         ndr->flags = _flags_save_string;
13596                 }
13597                 {
13598                         uint32_t _flags_save_string_array = ndr->flags;
13599                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13600                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
13601                         if (_ptr_previous_names) {
13602                                 NDR_PULL_ALLOC(ndr, r->previous_names);
13603                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
13604                         } else {
13605                                 r->previous_names = NULL;
13606                         }
13607                         ndr->flags = _flags_save_string_array;
13608                 }
13609                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
13610                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
13611                 {
13612                         uint32_t _flags_save_string = ndr->flags;
13613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13614                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
13615                         if (_ptr_manufacturer_name) {
13616                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
13617                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
13618                         } else {
13619                                 r->manufacturer_name = NULL;
13620                         }
13621                         ndr->flags = _flags_save_string;
13622                 }
13623                 {
13624                         uint32_t _flags_save_string = ndr->flags;
13625                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13626                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
13627                         if (_ptr_manufacturer_url) {
13628                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
13629                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
13630                         } else {
13631                                 r->manufacturer_url = NULL;
13632                         }
13633                         ndr->flags = _flags_save_string;
13634                 }
13635                 {
13636                         uint32_t _flags_save_string = ndr->flags;
13637                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13638                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
13639                         if (_ptr_hardware_id) {
13640                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
13641                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
13642                         } else {
13643                                 r->hardware_id = NULL;
13644                         }
13645                         ndr->flags = _flags_save_string;
13646                 }
13647                 {
13648                         uint32_t _flags_save_string = ndr->flags;
13649                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13650                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
13651                         if (_ptr_provider) {
13652                                 NDR_PULL_ALLOC(ndr, r->provider);
13653                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
13654                         } else {
13655                                 r->provider = NULL;
13656                         }
13657                         ndr->flags = _flags_save_string;
13658                 }
13659                 {
13660                         uint32_t _flags_save_string = ndr->flags;
13661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13662                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
13663                         if (_ptr_print_processor) {
13664                                 NDR_PULL_ALLOC(ndr, r->print_processor);
13665                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
13666                         } else {
13667                                 r->print_processor = NULL;
13668                         }
13669                         ndr->flags = _flags_save_string;
13670                 }
13671                 {
13672                         uint32_t _flags_save_string = ndr->flags;
13673                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13674                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
13675                         if (_ptr_vendor_setup) {
13676                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
13677                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
13678                         } else {
13679                                 r->vendor_setup = NULL;
13680                         }
13681                         ndr->flags = _flags_save_string;
13682                 }
13683                 {
13684                         uint32_t _flags_save_string_array = ndr->flags;
13685                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13686                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
13687                         if (_ptr_color_profiles) {
13688                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
13689                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
13690                         } else {
13691                                 r->color_profiles = NULL;
13692                         }
13693                         ndr->flags = _flags_save_string_array;
13694                 }
13695                 {
13696                         uint32_t _flags_save_string = ndr->flags;
13697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13698                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
13699                         if (_ptr_inf_path) {
13700                                 NDR_PULL_ALLOC(ndr, r->inf_path);
13701                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
13702                         } else {
13703                                 r->inf_path = NULL;
13704                         }
13705                         ndr->flags = _flags_save_string;
13706                 }
13707                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
13708                 {
13709                         uint32_t _flags_save_string_array = ndr->flags;
13710                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13711                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
13712                         if (_ptr_core_driver_dependencies) {
13713                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
13714                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
13715                         } else {
13716                                 r->core_driver_dependencies = NULL;
13717                         }
13718                         ndr->flags = _flags_save_string_array;
13719                 }
13720                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
13721                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
13722                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
13723         }
13724         if (ndr_flags & NDR_BUFFERS) {
13725                 {
13726                         uint32_t _flags_save_string = ndr->flags;
13727                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13728                         if (r->driver_name) {
13729                                 uint32_t _relative_save_offset;
13730                                 _relative_save_offset = ndr->offset;
13731                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13732                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13733                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13734                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13735                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13736                                 if (ndr->offset > ndr->relative_highest_offset) {
13737                                         ndr->relative_highest_offset = ndr->offset;
13738                                 }
13739                                 ndr->offset = _relative_save_offset;
13740                         }
13741                         ndr->flags = _flags_save_string;
13742                 }
13743                 {
13744                         uint32_t _flags_save_string = ndr->flags;
13745                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13746                         if (r->architecture) {
13747                                 uint32_t _relative_save_offset;
13748                                 _relative_save_offset = ndr->offset;
13749                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
13750                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
13751                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
13752                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
13753                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
13754                                 if (ndr->offset > ndr->relative_highest_offset) {
13755                                         ndr->relative_highest_offset = ndr->offset;
13756                                 }
13757                                 ndr->offset = _relative_save_offset;
13758                         }
13759                         ndr->flags = _flags_save_string;
13760                 }
13761                 {
13762                         uint32_t _flags_save_string = ndr->flags;
13763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13764                         if (r->driver_path) {
13765                                 uint32_t _relative_save_offset;
13766                                 _relative_save_offset = ndr->offset;
13767                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
13768                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13769                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
13770                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
13771                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
13772                                 if (ndr->offset > ndr->relative_highest_offset) {
13773                                         ndr->relative_highest_offset = ndr->offset;
13774                                 }
13775                                 ndr->offset = _relative_save_offset;
13776                         }
13777                         ndr->flags = _flags_save_string;
13778                 }
13779                 {
13780                         uint32_t _flags_save_string = ndr->flags;
13781                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13782                         if (r->data_file) {
13783                                 uint32_t _relative_save_offset;
13784                                 _relative_save_offset = ndr->offset;
13785                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
13786                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13787                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
13788                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
13789                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
13790                                 if (ndr->offset > ndr->relative_highest_offset) {
13791                                         ndr->relative_highest_offset = ndr->offset;
13792                                 }
13793                                 ndr->offset = _relative_save_offset;
13794                         }
13795                         ndr->flags = _flags_save_string;
13796                 }
13797                 {
13798                         uint32_t _flags_save_string = ndr->flags;
13799                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13800                         if (r->config_file) {
13801                                 uint32_t _relative_save_offset;
13802                                 _relative_save_offset = ndr->offset;
13803                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
13804                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13805                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
13806                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
13807                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
13808                                 if (ndr->offset > ndr->relative_highest_offset) {
13809                                         ndr->relative_highest_offset = ndr->offset;
13810                                 }
13811                                 ndr->offset = _relative_save_offset;
13812                         }
13813                         ndr->flags = _flags_save_string;
13814                 }
13815                 {
13816                         uint32_t _flags_save_string = ndr->flags;
13817                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13818                         if (r->help_file) {
13819                                 uint32_t _relative_save_offset;
13820                                 _relative_save_offset = ndr->offset;
13821                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
13822                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13823                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
13824                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
13825                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
13826                                 if (ndr->offset > ndr->relative_highest_offset) {
13827                                         ndr->relative_highest_offset = ndr->offset;
13828                                 }
13829                                 ndr->offset = _relative_save_offset;
13830                         }
13831                         ndr->flags = _flags_save_string;
13832                 }
13833                 {
13834                         uint32_t _flags_save_string_array = ndr->flags;
13835                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13836                         if (r->dependent_files) {
13837                                 uint32_t _relative_save_offset;
13838                                 _relative_save_offset = ndr->offset;
13839                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
13840                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
13841                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
13842                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
13843                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
13844                                 if (ndr->offset > ndr->relative_highest_offset) {
13845                                         ndr->relative_highest_offset = ndr->offset;
13846                                 }
13847                                 ndr->offset = _relative_save_offset;
13848                         }
13849                         ndr->flags = _flags_save_string_array;
13850                 }
13851                 {
13852                         uint32_t _flags_save_string = ndr->flags;
13853                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13854                         if (r->monitor_name) {
13855                                 uint32_t _relative_save_offset;
13856                                 _relative_save_offset = ndr->offset;
13857                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
13858                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13859                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
13860                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
13861                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
13862                                 if (ndr->offset > ndr->relative_highest_offset) {
13863                                         ndr->relative_highest_offset = ndr->offset;
13864                                 }
13865                                 ndr->offset = _relative_save_offset;
13866                         }
13867                         ndr->flags = _flags_save_string;
13868                 }
13869                 {
13870                         uint32_t _flags_save_string = ndr->flags;
13871                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13872                         if (r->default_datatype) {
13873                                 uint32_t _relative_save_offset;
13874                                 _relative_save_offset = ndr->offset;
13875                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
13876                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
13877                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
13878                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
13879                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
13880                                 if (ndr->offset > ndr->relative_highest_offset) {
13881                                         ndr->relative_highest_offset = ndr->offset;
13882                                 }
13883                                 ndr->offset = _relative_save_offset;
13884                         }
13885                         ndr->flags = _flags_save_string;
13886                 }
13887                 {
13888                         uint32_t _flags_save_string_array = ndr->flags;
13889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13890                         if (r->previous_names) {
13891                                 uint32_t _relative_save_offset;
13892                                 _relative_save_offset = ndr->offset;
13893                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
13894                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
13895                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
13896                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
13897                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
13898                                 if (ndr->offset > ndr->relative_highest_offset) {
13899                                         ndr->relative_highest_offset = ndr->offset;
13900                                 }
13901                                 ndr->offset = _relative_save_offset;
13902                         }
13903                         ndr->flags = _flags_save_string_array;
13904                 }
13905                 {
13906                         uint32_t _flags_save_string = ndr->flags;
13907                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13908                         if (r->manufacturer_name) {
13909                                 uint32_t _relative_save_offset;
13910                                 _relative_save_offset = ndr->offset;
13911                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
13912                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13913                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
13914                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
13915                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
13916                                 if (ndr->offset > ndr->relative_highest_offset) {
13917                                         ndr->relative_highest_offset = ndr->offset;
13918                                 }
13919                                 ndr->offset = _relative_save_offset;
13920                         }
13921                         ndr->flags = _flags_save_string;
13922                 }
13923                 {
13924                         uint32_t _flags_save_string = ndr->flags;
13925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13926                         if (r->manufacturer_url) {
13927                                 uint32_t _relative_save_offset;
13928                                 _relative_save_offset = ndr->offset;
13929                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
13930                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
13931                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
13932                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
13933                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13934                                 if (ndr->offset > ndr->relative_highest_offset) {
13935                                         ndr->relative_highest_offset = ndr->offset;
13936                                 }
13937                                 ndr->offset = _relative_save_offset;
13938                         }
13939                         ndr->flags = _flags_save_string;
13940                 }
13941                 {
13942                         uint32_t _flags_save_string = ndr->flags;
13943                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13944                         if (r->hardware_id) {
13945                                 uint32_t _relative_save_offset;
13946                                 _relative_save_offset = ndr->offset;
13947                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13948                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13949                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13950                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13951                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13952                                 if (ndr->offset > ndr->relative_highest_offset) {
13953                                         ndr->relative_highest_offset = ndr->offset;
13954                                 }
13955                                 ndr->offset = _relative_save_offset;
13956                         }
13957                         ndr->flags = _flags_save_string;
13958                 }
13959                 {
13960                         uint32_t _flags_save_string = ndr->flags;
13961                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13962                         if (r->provider) {
13963                                 uint32_t _relative_save_offset;
13964                                 _relative_save_offset = ndr->offset;
13965                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13966                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13967                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13968                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13969                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13970                                 if (ndr->offset > ndr->relative_highest_offset) {
13971                                         ndr->relative_highest_offset = ndr->offset;
13972                                 }
13973                                 ndr->offset = _relative_save_offset;
13974                         }
13975                         ndr->flags = _flags_save_string;
13976                 }
13977                 {
13978                         uint32_t _flags_save_string = ndr->flags;
13979                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13980                         if (r->print_processor) {
13981                                 uint32_t _relative_save_offset;
13982                                 _relative_save_offset = ndr->offset;
13983                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
13984                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
13985                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
13986                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
13987                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
13988                                 if (ndr->offset > ndr->relative_highest_offset) {
13989                                         ndr->relative_highest_offset = ndr->offset;
13990                                 }
13991                                 ndr->offset = _relative_save_offset;
13992                         }
13993                         ndr->flags = _flags_save_string;
13994                 }
13995                 {
13996                         uint32_t _flags_save_string = ndr->flags;
13997                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13998                         if (r->vendor_setup) {
13999                                 uint32_t _relative_save_offset;
14000                                 _relative_save_offset = ndr->offset;
14001                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
14002                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
14003                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
14004                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
14005                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
14006                                 if (ndr->offset > ndr->relative_highest_offset) {
14007                                         ndr->relative_highest_offset = ndr->offset;
14008                                 }
14009                                 ndr->offset = _relative_save_offset;
14010                         }
14011                         ndr->flags = _flags_save_string;
14012                 }
14013                 {
14014                         uint32_t _flags_save_string_array = ndr->flags;
14015                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14016                         if (r->color_profiles) {
14017                                 uint32_t _relative_save_offset;
14018                                 _relative_save_offset = ndr->offset;
14019                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
14020                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
14021                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
14022                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
14023                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
14024                                 if (ndr->offset > ndr->relative_highest_offset) {
14025                                         ndr->relative_highest_offset = ndr->offset;
14026                                 }
14027                                 ndr->offset = _relative_save_offset;
14028                         }
14029                         ndr->flags = _flags_save_string_array;
14030                 }
14031                 {
14032                         uint32_t _flags_save_string = ndr->flags;
14033                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14034                         if (r->inf_path) {
14035                                 uint32_t _relative_save_offset;
14036                                 _relative_save_offset = ndr->offset;
14037                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
14038                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
14039                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
14040                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
14041                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
14042                                 if (ndr->offset > ndr->relative_highest_offset) {
14043                                         ndr->relative_highest_offset = ndr->offset;
14044                                 }
14045                                 ndr->offset = _relative_save_offset;
14046                         }
14047                         ndr->flags = _flags_save_string;
14048                 }
14049                 {
14050                         uint32_t _flags_save_string_array = ndr->flags;
14051                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14052                         if (r->core_driver_dependencies) {
14053                                 uint32_t _relative_save_offset;
14054                                 _relative_save_offset = ndr->offset;
14055                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
14056                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
14057                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
14058                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
14059                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
14060                                 if (ndr->offset > ndr->relative_highest_offset) {
14061                                         ndr->relative_highest_offset = ndr->offset;
14062                                 }
14063                                 ndr->offset = _relative_save_offset;
14064                         }
14065                         ndr->flags = _flags_save_string_array;
14066                 }
14067         }
14068         return NDR_ERR_SUCCESS;
14069 }
14070
14071 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
14072 {
14073         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
14074         ndr->depth++;
14075         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14076         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14077         ndr->depth++;
14078         if (r->driver_name) {
14079                 ndr_print_string(ndr, "driver_name", r->driver_name);
14080         }
14081         ndr->depth--;
14082         ndr_print_ptr(ndr, "architecture", r->architecture);
14083         ndr->depth++;
14084         if (r->architecture) {
14085                 ndr_print_string(ndr, "architecture", r->architecture);
14086         }
14087         ndr->depth--;
14088         ndr_print_ptr(ndr, "driver_path", r->driver_path);
14089         ndr->depth++;
14090         if (r->driver_path) {
14091                 ndr_print_string(ndr, "driver_path", r->driver_path);
14092         }
14093         ndr->depth--;
14094         ndr_print_ptr(ndr, "data_file", r->data_file);
14095         ndr->depth++;
14096         if (r->data_file) {
14097                 ndr_print_string(ndr, "data_file", r->data_file);
14098         }
14099         ndr->depth--;
14100         ndr_print_ptr(ndr, "config_file", r->config_file);
14101         ndr->depth++;
14102         if (r->config_file) {
14103                 ndr_print_string(ndr, "config_file", r->config_file);
14104         }
14105         ndr->depth--;
14106         ndr_print_ptr(ndr, "help_file", r->help_file);
14107         ndr->depth++;
14108         if (r->help_file) {
14109                 ndr_print_string(ndr, "help_file", r->help_file);
14110         }
14111         ndr->depth--;
14112         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
14113         ndr->depth++;
14114         if (r->dependent_files) {
14115                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
14116         }
14117         ndr->depth--;
14118         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14119         ndr->depth++;
14120         if (r->monitor_name) {
14121                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14122         }
14123         ndr->depth--;
14124         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14125         ndr->depth++;
14126         if (r->default_datatype) {
14127                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14128         }
14129         ndr->depth--;
14130         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14131         ndr->depth++;
14132         if (r->previous_names) {
14133                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14134         }
14135         ndr->depth--;
14136         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14137         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14138         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14139         ndr->depth++;
14140         if (r->manufacturer_name) {
14141                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14142         }
14143         ndr->depth--;
14144         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14145         ndr->depth++;
14146         if (r->manufacturer_url) {
14147                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14148         }
14149         ndr->depth--;
14150         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14151         ndr->depth++;
14152         if (r->hardware_id) {
14153                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14154         }
14155         ndr->depth--;
14156         ndr_print_ptr(ndr, "provider", r->provider);
14157         ndr->depth++;
14158         if (r->provider) {
14159                 ndr_print_string(ndr, "provider", r->provider);
14160         }
14161         ndr->depth--;
14162         ndr_print_ptr(ndr, "print_processor", r->print_processor);
14163         ndr->depth++;
14164         if (r->print_processor) {
14165                 ndr_print_string(ndr, "print_processor", r->print_processor);
14166         }
14167         ndr->depth--;
14168         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
14169         ndr->depth++;
14170         if (r->vendor_setup) {
14171                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
14172         }
14173         ndr->depth--;
14174         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
14175         ndr->depth++;
14176         if (r->color_profiles) {
14177                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
14178         }
14179         ndr->depth--;
14180         ndr_print_ptr(ndr, "inf_path", r->inf_path);
14181         ndr->depth++;
14182         if (r->inf_path) {
14183                 ndr_print_string(ndr, "inf_path", r->inf_path);
14184         }
14185         ndr->depth--;
14186         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
14187         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14188         ndr->depth++;
14189         if (r->core_driver_dependencies) {
14190                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14191         }
14192         ndr->depth--;
14193         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
14194         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
14195         ndr->depth--;
14196 }
14197
14198 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
14199 {
14200         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
14201 }
14202
14203 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
14204 {
14205         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
14206         return NDR_ERR_SUCCESS;
14207 }
14208
14209 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
14210 {
14211         uint32_t v;
14212         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
14213         *r = v;
14214         return NDR_ERR_SUCCESS;
14215 }
14216
14217 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
14218 {
14219         const char *val = NULL;
14220
14221         switch (r) {
14222                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
14223                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
14224                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
14225                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
14226                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
14227         }
14228         ndr_print_enum(ndr, name, "ENUM", val, r);
14229 }
14230
14231 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
14232 {
14233         if (ndr_flags & NDR_SCALARS) {
14234                 NDR_CHECK(ndr_push_align(ndr, 5));
14235                 {
14236                         uint32_t _flags_save_string = ndr->flags;
14237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14238                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
14239                         ndr->flags = _flags_save_string;
14240                 }
14241                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
14242                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
14243                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
14244         }
14245         if (ndr_flags & NDR_BUFFERS) {
14246                 {
14247                         uint32_t _flags_save_string = ndr->flags;
14248                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14249                         if (r->file_name) {
14250                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
14251                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
14252                         }
14253                         ndr->flags = _flags_save_string;
14254                 }
14255         }
14256         return NDR_ERR_SUCCESS;
14257 }
14258
14259 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
14260 {
14261         uint32_t _ptr_file_name;
14262         TALLOC_CTX *_mem_save_file_name_0;
14263         if (ndr_flags & NDR_SCALARS) {
14264                 NDR_CHECK(ndr_pull_align(ndr, 5));
14265                 {
14266                         uint32_t _flags_save_string = ndr->flags;
14267                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14268                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
14269                         if (_ptr_file_name) {
14270                                 NDR_PULL_ALLOC(ndr, r->file_name);
14271                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
14272                         } else {
14273                                 r->file_name = NULL;
14274                         }
14275                         ndr->flags = _flags_save_string;
14276                 }
14277                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
14278                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
14279                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
14280         }
14281         if (ndr_flags & NDR_BUFFERS) {
14282                 {
14283                         uint32_t _flags_save_string = ndr->flags;
14284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14285                         if (r->file_name) {
14286                                 uint32_t _relative_save_offset;
14287                                 _relative_save_offset = ndr->offset;
14288                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
14289                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14290                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
14291                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
14292                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
14293                                 if (ndr->offset > ndr->relative_highest_offset) {
14294                                         ndr->relative_highest_offset = ndr->offset;
14295                                 }
14296                                 ndr->offset = _relative_save_offset;
14297                         }
14298                         ndr->flags = _flags_save_string;
14299                 }
14300         }
14301         return NDR_ERR_SUCCESS;
14302 }
14303
14304 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
14305 {
14306         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
14307         ndr->depth++;
14308         ndr_print_ptr(ndr, "file_name", r->file_name);
14309         ndr->depth++;
14310         if (r->file_name) {
14311                 ndr_print_string(ndr, "file_name", r->file_name);
14312         }
14313         ndr->depth--;
14314         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
14315         ndr_print_uint32(ndr, "file_version", r->file_version);
14316         ndr->depth--;
14317 }
14318
14319 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
14320 {
14321         uint32_t cntr_file_info_1;
14322         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
14323         ndr->depth++;
14324         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14325         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14326         ndr->depth++;
14327         if (r->driver_name) {
14328                 ndr_print_string(ndr, "driver_name", r->driver_name);
14329         }
14330         ndr->depth--;
14331         ndr_print_ptr(ndr, "architecture", r->architecture);
14332         ndr->depth++;
14333         if (r->architecture) {
14334                 ndr_print_string(ndr, "architecture", r->architecture);
14335         }
14336         ndr->depth--;
14337         ndr_print_ptr(ndr, "file_info", r->file_info);
14338         ndr->depth++;
14339         if (r->file_info) {
14340                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
14341                 ndr->depth++;
14342                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
14343                         char *idx_1=NULL;
14344                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
14345                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
14346                                 free(idx_1);
14347                         }
14348                 }
14349                 ndr->depth--;
14350         }
14351         ndr->depth--;
14352         ndr_print_uint32(ndr, "file_count", r->file_count);
14353         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14354         ndr->depth++;
14355         if (r->monitor_name) {
14356                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14357         }
14358         ndr->depth--;
14359         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14360         ndr->depth++;
14361         if (r->default_datatype) {
14362                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14363         }
14364         ndr->depth--;
14365         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14366         ndr->depth++;
14367         if (r->previous_names) {
14368                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14369         }
14370         ndr->depth--;
14371         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14372         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14373         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14374         ndr->depth++;
14375         if (r->manufacturer_name) {
14376                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14377         }
14378         ndr->depth--;
14379         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14380         ndr->depth++;
14381         if (r->manufacturer_url) {
14382                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14383         }
14384         ndr->depth--;
14385         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14386         ndr->depth++;
14387         if (r->hardware_id) {
14388                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14389         }
14390         ndr->depth--;
14391         ndr_print_ptr(ndr, "provider", r->provider);
14392         ndr->depth++;
14393         if (r->provider) {
14394                 ndr_print_string(ndr, "provider", r->provider);
14395         }
14396         ndr->depth--;
14397         ndr->depth--;
14398 }
14399
14400 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
14401 {
14402         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
14403 }
14404
14405 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
14406 {
14407         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14408         if (ndr_flags & NDR_SCALARS) {
14409                 int level = ndr_push_get_switch_value(ndr, r);
14410                 NDR_CHECK(ndr_push_union_align(ndr, 8));
14411                 switch (level) {
14412                         case 1: {
14413                                 NDR_CHECK(ndr_push_align(ndr, 5));
14414                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14415                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14416                         break; }
14417
14418                         case 2: {
14419                                 NDR_CHECK(ndr_push_align(ndr, 5));
14420                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14421                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14422                         break; }
14423
14424                         case 3: {
14425                                 NDR_CHECK(ndr_push_align(ndr, 5));
14426                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14427                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14428                         break; }
14429
14430                         case 4: {
14431                                 NDR_CHECK(ndr_push_align(ndr, 5));
14432                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14433                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14434                         break; }
14435
14436                         case 5: {
14437                                 NDR_CHECK(ndr_push_align(ndr, 5));
14438                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14439                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14440                         break; }
14441
14442                         case 6: {
14443                                 NDR_CHECK(ndr_push_align(ndr, 8));
14444                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14445                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14446                         break; }
14447
14448                         case 8: {
14449                                 NDR_CHECK(ndr_push_align(ndr, 8));
14450                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14451                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14452                         break; }
14453
14454                         case 101: {
14455                                 NDR_CHECK(ndr_push_align(ndr, 8));
14456                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14457                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14458                         break; }
14459
14460                         default: {
14461                         break; }
14462
14463                 }
14464         }
14465         if (ndr_flags & NDR_BUFFERS) {
14466                 int level = ndr_push_get_switch_value(ndr, r);
14467                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14468                 switch (level) {
14469                         case 1:
14470                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14471                         break;
14472
14473                         case 2:
14474                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14475                         break;
14476
14477                         case 3:
14478                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14479                         break;
14480
14481                         case 4:
14482                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14483                         break;
14484
14485                         case 5:
14486                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14487                         break;
14488
14489                         case 6:
14490                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14491                         break;
14492
14493                         case 8:
14494                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14495                         break;
14496
14497                         case 101:
14498                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14499                         break;
14500
14501                         default:
14502                         break;
14503
14504                 }
14505         }
14506         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14507         return NDR_ERR_SUCCESS;
14508 }
14509
14510 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
14511 {
14512         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14513         int level;
14514         level = ndr_pull_get_switch_value(ndr, r);
14515         if (ndr_flags & NDR_SCALARS) {
14516                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
14517                 switch (level) {
14518                         case 1: {
14519                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14520                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14521                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14522                         break; }
14523
14524                         case 2: {
14525                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14526                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14527                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14528                         break; }
14529
14530                         case 3: {
14531                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14532                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14533                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14534                         break; }
14535
14536                         case 4: {
14537                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14538                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14539                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14540                         break; }
14541
14542                         case 5: {
14543                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14544                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14545                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14546                         break; }
14547
14548                         case 6: {
14549                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14550                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14551                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14552                         break; }
14553
14554                         case 8: {
14555                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14556                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14557                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14558                         break; }
14559
14560                         case 101: {
14561                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14562                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14563                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14564                         break; }
14565
14566                         default: {
14567                         break; }
14568
14569                 }
14570         }
14571         if (ndr_flags & NDR_BUFFERS) {
14572                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14573                 switch (level) {
14574                         case 1:
14575                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14576                         break;
14577
14578                         case 2:
14579                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14580                         break;
14581
14582                         case 3:
14583                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14584                         break;
14585
14586                         case 4:
14587                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14588                         break;
14589
14590                         case 5:
14591                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14592                         break;
14593
14594                         case 6:
14595                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14596                         break;
14597
14598                         case 8:
14599                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14600                         break;
14601
14602                         case 101:
14603                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14604                         break;
14605
14606                         default:
14607                         break;
14608
14609                 }
14610         }
14611         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14612         return NDR_ERR_SUCCESS;
14613 }
14614
14615 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
14616 {
14617         int level;
14618         level = ndr_print_get_switch_value(ndr, r);
14619         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
14620         switch (level) {
14621                 case 1:
14622                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
14623                 break;
14624
14625                 case 2:
14626                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
14627                 break;
14628
14629                 case 3:
14630                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
14631                 break;
14632
14633                 case 4:
14634                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
14635                 break;
14636
14637                 case 5:
14638                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
14639                 break;
14640
14641                 case 6:
14642                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
14643                 break;
14644
14645                 case 8:
14646                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
14647                 break;
14648
14649                 case 101:
14650                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
14651                 break;
14652
14653                 default:
14654                 break;
14655
14656         }
14657 }
14658
14659 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14660 {
14661         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
14662 }
14663
14664 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
14665 {
14666         if (ndr_flags & NDR_SCALARS) {
14667                 NDR_CHECK(ndr_push_align(ndr, 4));
14668                 {
14669                         uint32_t _flags_save_string = ndr->flags;
14670                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14671                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14672                         ndr->flags = _flags_save_string;
14673                 }
14674                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
14675         }
14676         if (ndr_flags & NDR_BUFFERS) {
14677         }
14678         return NDR_ERR_SUCCESS;
14679 }
14680
14681 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
14682 {
14683         if (ndr_flags & NDR_SCALARS) {
14684                 NDR_CHECK(ndr_pull_align(ndr, 4));
14685                 {
14686                         uint32_t _flags_save_string = ndr->flags;
14687                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14688                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14689                         ndr->flags = _flags_save_string;
14690                 }
14691                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
14692         }
14693         if (ndr_flags & NDR_BUFFERS) {
14694         }
14695         return NDR_ERR_SUCCESS;
14696 }
14697
14698 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
14699 {
14700         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
14701         ndr->depth++;
14702         ndr_print_string(ndr, "directory_name", r->directory_name);
14703         ndr->depth--;
14704 }
14705
14706 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14707 {
14708         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
14709 }
14710
14711 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
14712 {
14713         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14714         if (ndr_flags & NDR_SCALARS) {
14715                 int level = ndr_push_get_switch_value(ndr, r);
14716                 NDR_CHECK(ndr_push_union_align(ndr, 4));
14717                 switch (level) {
14718                         case 1: {
14719                                 NDR_CHECK(ndr_push_align(ndr, 4));
14720                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14721                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14722                         break; }
14723
14724                         default: {
14725                                 NDR_CHECK(ndr_push_align(ndr, 4));
14726                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14727                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14728                         break; }
14729
14730                 }
14731         }
14732         if (ndr_flags & NDR_BUFFERS) {
14733                 int level = ndr_push_get_switch_value(ndr, r);
14734                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14735                 switch (level) {
14736                         case 1:
14737                         break;
14738
14739                         default:
14740                         break;
14741
14742                 }
14743         }
14744         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14745         return NDR_ERR_SUCCESS;
14746 }
14747
14748 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
14749 {
14750         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14751         int level;
14752         level = ndr_pull_get_switch_value(ndr, r);
14753         if (ndr_flags & NDR_SCALARS) {
14754                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
14755                 switch (level) {
14756                         case 1: {
14757                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14758                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14759                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14760                         break; }
14761
14762                         default: {
14763                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14764                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14765                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14766                         break; }
14767
14768                 }
14769         }
14770         if (ndr_flags & NDR_BUFFERS) {
14771                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14772                 switch (level) {
14773                         case 1:
14774                         break;
14775
14776                         default:
14777                         break;
14778
14779                 }
14780         }
14781         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14782         return NDR_ERR_SUCCESS;
14783 }
14784
14785 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
14786 {
14787         int level;
14788         level = ndr_print_get_switch_value(ndr, r);
14789         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
14790         switch (level) {
14791                 case 1:
14792                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
14793                 break;
14794
14795                 default:
14796                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
14797                 break;
14798
14799         }
14800 }
14801
14802 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14803 {
14804         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
14805 }
14806
14807 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
14808 {
14809         if (ndr_flags & NDR_SCALARS) {
14810                 NDR_CHECK(ndr_push_align(ndr, 5));
14811                 {
14812                         uint32_t _flags_save_string = ndr->flags;
14813                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14814                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
14815                         ndr->flags = _flags_save_string;
14816                 }
14817                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
14818         }
14819         if (ndr_flags & NDR_BUFFERS) {
14820                 {
14821                         uint32_t _flags_save_string = ndr->flags;
14822                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14823                         if (r->print_processor_name) {
14824                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
14825                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
14826                         }
14827                         ndr->flags = _flags_save_string;
14828                 }
14829         }
14830         return NDR_ERR_SUCCESS;
14831 }
14832
14833 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
14834 {
14835         uint32_t _ptr_print_processor_name;
14836         TALLOC_CTX *_mem_save_print_processor_name_0;
14837         if (ndr_flags & NDR_SCALARS) {
14838                 NDR_CHECK(ndr_pull_align(ndr, 5));
14839                 {
14840                         uint32_t _flags_save_string = ndr->flags;
14841                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14842                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
14843                         if (_ptr_print_processor_name) {
14844                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
14845                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
14846                         } else {
14847                                 r->print_processor_name = NULL;
14848                         }
14849                         ndr->flags = _flags_save_string;
14850                 }
14851                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
14852         }
14853         if (ndr_flags & NDR_BUFFERS) {
14854                 {
14855                         uint32_t _flags_save_string = ndr->flags;
14856                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14857                         if (r->print_processor_name) {
14858                                 uint32_t _relative_save_offset;
14859                                 _relative_save_offset = ndr->offset;
14860                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
14861                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14862                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
14863                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
14864                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
14865                                 if (ndr->offset > ndr->relative_highest_offset) {
14866                                         ndr->relative_highest_offset = ndr->offset;
14867                                 }
14868                                 ndr->offset = _relative_save_offset;
14869                         }
14870                         ndr->flags = _flags_save_string;
14871                 }
14872         }
14873         return NDR_ERR_SUCCESS;
14874 }
14875
14876 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
14877 {
14878         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
14879         ndr->depth++;
14880         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
14881         ndr->depth++;
14882         if (r->print_processor_name) {
14883                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
14884         }
14885         ndr->depth--;
14886         ndr->depth--;
14887 }
14888
14889 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14890 {
14891         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
14892 }
14893
14894 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
14895 {
14896         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14897         if (ndr_flags & NDR_SCALARS) {
14898                 int level = ndr_push_get_switch_value(ndr, r);
14899                 NDR_CHECK(ndr_push_union_align(ndr, 5));
14900                 switch (level) {
14901                         case 1: {
14902                                 NDR_CHECK(ndr_push_align(ndr, 5));
14903                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14904                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
14905                         break; }
14906
14907                         default: {
14908                         break; }
14909
14910                 }
14911         }
14912         if (ndr_flags & NDR_BUFFERS) {
14913                 int level = ndr_push_get_switch_value(ndr, r);
14914                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14915                 switch (level) {
14916                         case 1:
14917                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
14918                         break;
14919
14920                         default:
14921                         break;
14922
14923                 }
14924         }
14925         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14926         return NDR_ERR_SUCCESS;
14927 }
14928
14929 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
14930 {
14931         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14932         int level;
14933         level = ndr_pull_get_switch_value(ndr, r);
14934         if (ndr_flags & NDR_SCALARS) {
14935                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
14936                 switch (level) {
14937                         case 1: {
14938                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14939                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14940                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
14941                         break; }
14942
14943                         default: {
14944                         break; }
14945
14946                 }
14947         }
14948         if (ndr_flags & NDR_BUFFERS) {
14949                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14950                 switch (level) {
14951                         case 1:
14952                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
14953                         break;
14954
14955                         default:
14956                         break;
14957
14958                 }
14959         }
14960         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14961         return NDR_ERR_SUCCESS;
14962 }
14963
14964 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
14965 {
14966         int level;
14967         level = ndr_print_get_switch_value(ndr, r);
14968         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
14969         switch (level) {
14970                 case 1:
14971                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
14972                 break;
14973
14974                 default:
14975                 break;
14976
14977         }
14978 }
14979
14980 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14981 {
14982         if (ndr_flags & NDR_SCALARS) {
14983                 NDR_CHECK(ndr_push_align(ndr, 4));
14984                 {
14985                         uint32_t _flags_save_string = ndr->flags;
14986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14987                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14988                         ndr->flags = _flags_save_string;
14989                 }
14990                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
14991         }
14992         if (ndr_flags & NDR_BUFFERS) {
14993         }
14994         return NDR_ERR_SUCCESS;
14995 }
14996
14997 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
14998 {
14999         if (ndr_flags & NDR_SCALARS) {
15000                 NDR_CHECK(ndr_pull_align(ndr, 4));
15001                 {
15002                         uint32_t _flags_save_string = ndr->flags;
15003                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15004                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
15005                         ndr->flags = _flags_save_string;
15006                 }
15007                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15008         }
15009         if (ndr_flags & NDR_BUFFERS) {
15010         }
15011         return NDR_ERR_SUCCESS;
15012 }
15013
15014 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
15015 {
15016         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
15017         ndr->depth++;
15018         ndr_print_string(ndr, "directory_name", r->directory_name);
15019         ndr->depth--;
15020 }
15021
15022 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15023 {
15024         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
15025 }
15026
15027 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
15028 {
15029         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15030         if (ndr_flags & NDR_SCALARS) {
15031                 int level = ndr_push_get_switch_value(ndr, r);
15032                 NDR_CHECK(ndr_push_union_align(ndr, 4));
15033                 switch (level) {
15034                         case 1: {
15035                                 NDR_CHECK(ndr_push_align(ndr, 4));
15036                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15037                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15038                         break; }
15039
15040                         default: {
15041                                 NDR_CHECK(ndr_push_align(ndr, 4));
15042                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15043                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15044                         break; }
15045
15046                 }
15047         }
15048         if (ndr_flags & NDR_BUFFERS) {
15049                 int level = ndr_push_get_switch_value(ndr, r);
15050                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15051                 switch (level) {
15052                         case 1:
15053                         break;
15054
15055                         default:
15056                         break;
15057
15058                 }
15059         }
15060         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15061         return NDR_ERR_SUCCESS;
15062 }
15063
15064 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
15065 {
15066         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15067         int level;
15068         level = ndr_pull_get_switch_value(ndr, r);
15069         if (ndr_flags & NDR_SCALARS) {
15070                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
15071                 switch (level) {
15072                         case 1: {
15073                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15074                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15075                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15076                         break; }
15077
15078                         default: {
15079                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15080                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15081                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15082                         break; }
15083
15084                 }
15085         }
15086         if (ndr_flags & NDR_BUFFERS) {
15087                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15088                 switch (level) {
15089                         case 1:
15090                         break;
15091
15092                         default:
15093                         break;
15094
15095                 }
15096         }
15097         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15098         return NDR_ERR_SUCCESS;
15099 }
15100
15101 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
15102 {
15103         int level;
15104         level = ndr_print_get_switch_value(ndr, r);
15105         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
15106         switch (level) {
15107                 case 1:
15108                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15109                 break;
15110
15111                 default:
15112                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15113                 break;
15114
15115         }
15116 }
15117
15118 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15119 {
15120         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
15121 }
15122
15123 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
15124 {
15125         if (ndr_flags & NDR_SCALARS) {
15126                 NDR_CHECK(ndr_push_align(ndr, 5));
15127                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
15128                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
15129                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
15130                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15131         }
15132         if (ndr_flags & NDR_BUFFERS) {
15133                 if (r->document_name) {
15134                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15135                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15136                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15137                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15138                 }
15139                 if (r->output_file) {
15140                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15141                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15142                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15143                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15144                 }
15145                 if (r->datatype) {
15146                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15147                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15148                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15149                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15150                 }
15151         }
15152         return NDR_ERR_SUCCESS;
15153 }
15154
15155 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
15156 {
15157         uint32_t _ptr_document_name;
15158         TALLOC_CTX *_mem_save_document_name_0;
15159         uint32_t _ptr_output_file;
15160         TALLOC_CTX *_mem_save_output_file_0;
15161         uint32_t _ptr_datatype;
15162         TALLOC_CTX *_mem_save_datatype_0;
15163         if (ndr_flags & NDR_SCALARS) {
15164                 NDR_CHECK(ndr_pull_align(ndr, 5));
15165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
15166                 if (_ptr_document_name) {
15167                         NDR_PULL_ALLOC(ndr, r->document_name);
15168                 } else {
15169                         r->document_name = NULL;
15170                 }
15171                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
15172                 if (_ptr_output_file) {
15173                         NDR_PULL_ALLOC(ndr, r->output_file);
15174                 } else {
15175                         r->output_file = NULL;
15176                 }
15177                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
15178                 if (_ptr_datatype) {
15179                         NDR_PULL_ALLOC(ndr, r->datatype);
15180                 } else {
15181                         r->datatype = NULL;
15182                 }
15183                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15184         }
15185         if (ndr_flags & NDR_BUFFERS) {
15186                 if (r->document_name) {
15187                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15188                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
15189                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
15190                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
15191                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
15192                                 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));
15193                         }
15194                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
15195                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
15196                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
15197                 }
15198                 if (r->output_file) {
15199                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
15200                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
15201                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
15202                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
15203                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
15204                                 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));
15205                         }
15206                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
15207                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
15208                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
15209                 }
15210                 if (r->datatype) {
15211                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
15212                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
15213                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
15214                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
15215                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
15216                                 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));
15217                         }
15218                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
15219                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
15220                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
15221                 }
15222         }
15223         return NDR_ERR_SUCCESS;
15224 }
15225
15226 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
15227 {
15228         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
15229         ndr->depth++;
15230         ndr_print_ptr(ndr, "document_name", r->document_name);
15231         ndr->depth++;
15232         if (r->document_name) {
15233                 ndr_print_string(ndr, "document_name", r->document_name);
15234         }
15235         ndr->depth--;
15236         ndr_print_ptr(ndr, "output_file", r->output_file);
15237         ndr->depth++;
15238         if (r->output_file) {
15239                 ndr_print_string(ndr, "output_file", r->output_file);
15240         }
15241         ndr->depth--;
15242         ndr_print_ptr(ndr, "datatype", r->datatype);
15243         ndr->depth++;
15244         if (r->datatype) {
15245                 ndr_print_string(ndr, "datatype", r->datatype);
15246         }
15247         ndr->depth--;
15248         ndr->depth--;
15249 }
15250
15251 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
15252 {
15253         if (ndr_flags & NDR_SCALARS) {
15254                 int level = ndr_push_get_switch_value(ndr, r);
15255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15256                 NDR_CHECK(ndr_push_union_align(ndr, 5));
15257                 switch (level) {
15258                         case 1: {
15259                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15260                         break; }
15261
15262                         case 2: {
15263                         break; }
15264
15265                         case 3: {
15266                         break; }
15267
15268                         default: {
15269                         break; }
15270
15271                 }
15272         }
15273         if (ndr_flags & NDR_BUFFERS) {
15274                 int level = ndr_push_get_switch_value(ndr, r);
15275                 switch (level) {
15276                         case 1:
15277                                 if (r->info1) {
15278                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15279                                 }
15280                         break;
15281
15282                         case 2:
15283                         break;
15284
15285                         case 3:
15286                         break;
15287
15288                         default:
15289                         break;
15290
15291                 }
15292         }
15293         return NDR_ERR_SUCCESS;
15294 }
15295
15296 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
15297 {
15298         int level;
15299         uint32_t _level;
15300         TALLOC_CTX *_mem_save_info1_0;
15301         level = ndr_pull_get_switch_value(ndr, r);
15302         if (ndr_flags & NDR_SCALARS) {
15303                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15304                 if (_level != level) {
15305                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
15306                 }
15307                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
15308                 switch (level) {
15309                         case 1: {
15310                                 uint32_t _ptr_info1;
15311                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15312                                 if (_ptr_info1) {
15313                                         NDR_PULL_ALLOC(ndr, r->info1);
15314                                 } else {
15315                                         r->info1 = NULL;
15316                                 }
15317                         break; }
15318
15319                         case 2: {
15320                         break; }
15321
15322                         case 3: {
15323                         break; }
15324
15325                         default: {
15326                         break; }
15327
15328                 }
15329         }
15330         if (ndr_flags & NDR_BUFFERS) {
15331                 switch (level) {
15332                         case 1:
15333                                 if (r->info1) {
15334                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15335                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15336                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15337                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15338                                 }
15339                         break;
15340
15341                         case 2:
15342                         break;
15343
15344                         case 3:
15345                         break;
15346
15347                         default:
15348                         break;
15349
15350                 }
15351         }
15352         return NDR_ERR_SUCCESS;
15353 }
15354
15355 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
15356 {
15357         int level;
15358         level = ndr_print_get_switch_value(ndr, r);
15359         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
15360         switch (level) {
15361                 case 1:
15362                         ndr_print_ptr(ndr, "info1", r->info1);
15363                         ndr->depth++;
15364                         if (r->info1) {
15365                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
15366                         }
15367                         ndr->depth--;
15368                 break;
15369
15370                 case 2:
15371                 break;
15372
15373                 case 3:
15374                 break;
15375
15376                 default:
15377                 break;
15378
15379         }
15380 }
15381
15382 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
15383 {
15384         if (ndr_flags & NDR_SCALARS) {
15385                 NDR_CHECK(ndr_push_align(ndr, 4));
15386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
15387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15391                 {
15392                         uint32_t _flags_save_string = ndr->flags;
15393                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15394                         {
15395                                 struct ndr_push *_ndr_extra_string;
15396                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15397                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15398                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15399                         }
15400                         ndr->flags = _flags_save_string;
15401                 }
15402                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15403         }
15404         if (ndr_flags & NDR_BUFFERS) {
15405         }
15406         return NDR_ERR_SUCCESS;
15407 }
15408
15409 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
15410 {
15411         if (ndr_flags & NDR_SCALARS) {
15412                 NDR_CHECK(ndr_pull_align(ndr, 4));
15413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15418                 {
15419                         uint32_t _flags_save_string = ndr->flags;
15420                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15421                         {
15422                                 struct ndr_pull *_ndr_extra_string;
15423                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15424                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15425                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15426                         }
15427                         ndr->flags = _flags_save_string;
15428                 }
15429                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15430         }
15431         if (ndr_flags & NDR_BUFFERS) {
15432         }
15433         return NDR_ERR_SUCCESS;
15434 }
15435
15436 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
15437 {
15438         ndr_print_struct(ndr, name, "spoolss_OSVersion");
15439         ndr->depth++;
15440         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);
15441         ndr_print_uint32(ndr, "major", r->major);
15442         ndr_print_uint32(ndr, "minor", r->minor);
15443         ndr_print_uint32(ndr, "build", r->build);
15444         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15445         ndr_print_string(ndr, "extra_string", r->extra_string);
15446         ndr->depth--;
15447 }
15448
15449 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
15450 {
15451         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
15452 }
15453
15454 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
15455 {
15456         if (ndr_flags & NDR_SCALARS) {
15457                 NDR_CHECK(ndr_push_align(ndr, 4));
15458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
15459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15461                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15462                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15463                 {
15464                         uint32_t _flags_save_string = ndr->flags;
15465                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15466                         {
15467                                 struct ndr_push *_ndr_extra_string;
15468                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15469                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15470                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15471                         }
15472                         ndr->flags = _flags_save_string;
15473                 }
15474                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_major));
15475                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_minor));
15476                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->suite_mask));
15477                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->product_type));
15478                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->reserved));
15479                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15480         }
15481         if (ndr_flags & NDR_BUFFERS) {
15482         }
15483         return NDR_ERR_SUCCESS;
15484 }
15485
15486 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
15487 {
15488         if (ndr_flags & NDR_SCALARS) {
15489                 NDR_CHECK(ndr_pull_align(ndr, 4));
15490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15494                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15495                 {
15496                         uint32_t _flags_save_string = ndr->flags;
15497                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15498                         {
15499                                 struct ndr_pull *_ndr_extra_string;
15500                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15501                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15502                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15503                         }
15504                         ndr->flags = _flags_save_string;
15505                 }
15506                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_major));
15507                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_minor));
15508                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->suite_mask));
15509                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->product_type));
15510                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->reserved));
15511                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15512         }
15513         if (ndr_flags & NDR_BUFFERS) {
15514         }
15515         return NDR_ERR_SUCCESS;
15516 }
15517
15518 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
15519 {
15520         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
15521         ndr->depth++;
15522         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);
15523         ndr_print_uint32(ndr, "major", r->major);
15524         ndr_print_uint32(ndr, "minor", r->minor);
15525         ndr_print_uint32(ndr, "build", r->build);
15526         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15527         ndr_print_string(ndr, "extra_string", r->extra_string);
15528         ndr_print_uint16(ndr, "service_pack_major", r->service_pack_major);
15529         ndr_print_uint16(ndr, "service_pack_minor", r->service_pack_minor);
15530         ndr_print_uint16(ndr, "suite_mask", r->suite_mask);
15531         ndr_print_uint8(ndr, "product_type", r->product_type);
15532         ndr_print_uint8(ndr, "reserved", r->reserved);
15533         ndr->depth--;
15534 }
15535
15536 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
15537 {
15538         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
15539 }
15540
15541 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
15542 {
15543         if (ndr_flags & NDR_SCALARS) {
15544                 int level = ndr_push_get_switch_value(ndr, r);
15545                 NDR_CHECK(ndr_push_union_align(ndr, 4));
15546                 switch (level) {
15547                         case REG_NONE: {
15548                         break; }
15549
15550                         case REG_SZ: {
15551                                 {
15552                                         uint32_t _flags_save_string = ndr->flags;
15553                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15554                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
15555                                         ndr->flags = _flags_save_string;
15556                                 }
15557                         break; }
15558
15559                         case REG_BINARY: {
15560                                 {
15561                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15562                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15563                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
15564                                         ndr->flags = _flags_save_DATA_BLOB;
15565                                 }
15566                         break; }
15567
15568                         case REG_DWORD: {
15569                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
15570                         break; }
15571
15572                         case REG_MULTI_SZ: {
15573                                 {
15574                                         uint32_t _flags_save_string_array = ndr->flags;
15575                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15576                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
15577                                         ndr->flags = _flags_save_string_array;
15578                                 }
15579                         break; }
15580
15581                         default: {
15582                                 {
15583                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15584                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15585                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
15586                                         ndr->flags = _flags_save_DATA_BLOB;
15587                                 }
15588                         break; }
15589
15590                 }
15591         }
15592         if (ndr_flags & NDR_BUFFERS) {
15593                 int level = ndr_push_get_switch_value(ndr, r);
15594                 switch (level) {
15595                         case REG_NONE:
15596                         break;
15597
15598                         case REG_SZ:
15599                         break;
15600
15601                         case REG_BINARY:
15602                         break;
15603
15604                         case REG_DWORD:
15605                         break;
15606
15607                         case REG_MULTI_SZ:
15608                         break;
15609
15610                         default:
15611                         break;
15612
15613                 }
15614         }
15615         return NDR_ERR_SUCCESS;
15616 }
15617
15618 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
15619 {
15620         int level;
15621         level = ndr_pull_get_switch_value(ndr, r);
15622         if (ndr_flags & NDR_SCALARS) {
15623                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
15624                 switch (level) {
15625                         case REG_NONE: {
15626                         break; }
15627
15628                         case REG_SZ: {
15629                                 {
15630                                         uint32_t _flags_save_string = ndr->flags;
15631                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15632                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
15633                                         ndr->flags = _flags_save_string;
15634                                 }
15635                         break; }
15636
15637                         case REG_BINARY: {
15638                                 {
15639                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15640                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15641                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
15642                                         ndr->flags = _flags_save_DATA_BLOB;
15643                                 }
15644                         break; }
15645
15646                         case REG_DWORD: {
15647                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
15648                         break; }
15649
15650                         case REG_MULTI_SZ: {
15651                                 {
15652                                         uint32_t _flags_save_string_array = ndr->flags;
15653                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15654                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
15655                                         ndr->flags = _flags_save_string_array;
15656                                 }
15657                         break; }
15658
15659                         default: {
15660                                 {
15661                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15662                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15663                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
15664                                         ndr->flags = _flags_save_DATA_BLOB;
15665                                 }
15666                         break; }
15667
15668                 }
15669         }
15670         if (ndr_flags & NDR_BUFFERS) {
15671                 switch (level) {
15672                         case REG_NONE:
15673                         break;
15674
15675                         case REG_SZ:
15676                         break;
15677
15678                         case REG_BINARY:
15679                         break;
15680
15681                         case REG_DWORD:
15682                         break;
15683
15684                         case REG_MULTI_SZ:
15685                         break;
15686
15687                         default:
15688                         break;
15689
15690                 }
15691         }
15692         return NDR_ERR_SUCCESS;
15693 }
15694
15695 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
15696 {
15697         int level;
15698         level = ndr_print_get_switch_value(ndr, r);
15699         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
15700         switch (level) {
15701                 case REG_NONE:
15702                 break;
15703
15704                 case REG_SZ:
15705                         ndr_print_string(ndr, "string", r->string);
15706                 break;
15707
15708                 case REG_BINARY:
15709                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
15710                 break;
15711
15712                 case REG_DWORD:
15713                         ndr_print_uint32(ndr, "value", r->value);
15714                 break;
15715
15716                 case REG_MULTI_SZ:
15717                         ndr_print_string_array(ndr, "string_array", r->string_array);
15718                 break;
15719
15720                 default:
15721                         ndr_print_DATA_BLOB(ndr, "data", r->data);
15722                 break;
15723
15724         }
15725 }
15726
15727 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15728 {
15729         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
15730 }
15731
15732 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
15733 {
15734         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
15735         return NDR_ERR_SUCCESS;
15736 }
15737
15738 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
15739 {
15740         uint32_t v;
15741         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
15742         *r = v;
15743         return NDR_ERR_SUCCESS;
15744 }
15745
15746 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
15747 {
15748         const char *val = NULL;
15749
15750         switch (r) {
15751                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
15752                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
15753                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
15754         }
15755         ndr_print_enum(ndr, name, "ENUM", val, r);
15756 }
15757
15758 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
15759 {
15760         if (ndr_flags & NDR_SCALARS) {
15761                 NDR_CHECK(ndr_push_align(ndr, 4));
15762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
15763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
15764                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15765         }
15766         if (ndr_flags & NDR_BUFFERS) {
15767         }
15768         return NDR_ERR_SUCCESS;
15769 }
15770
15771 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
15772 {
15773         if (ndr_flags & NDR_SCALARS) {
15774                 NDR_CHECK(ndr_pull_align(ndr, 4));
15775                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
15776                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
15777                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15778         }
15779         if (ndr_flags & NDR_BUFFERS) {
15780         }
15781         return NDR_ERR_SUCCESS;
15782 }
15783
15784 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
15785 {
15786         ndr_print_struct(ndr, name, "spoolss_FormSize");
15787         ndr->depth++;
15788         ndr_print_uint32(ndr, "width", r->width);
15789         ndr_print_uint32(ndr, "height", r->height);
15790         ndr->depth--;
15791 }
15792
15793 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
15794 {
15795         if (ndr_flags & NDR_SCALARS) {
15796                 NDR_CHECK(ndr_push_align(ndr, 4));
15797                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
15798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
15799                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
15800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
15801                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15802         }
15803         if (ndr_flags & NDR_BUFFERS) {
15804         }
15805         return NDR_ERR_SUCCESS;
15806 }
15807
15808 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
15809 {
15810         if (ndr_flags & NDR_SCALARS) {
15811                 NDR_CHECK(ndr_pull_align(ndr, 4));
15812                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
15813                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
15814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
15815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
15816                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15817         }
15818         if (ndr_flags & NDR_BUFFERS) {
15819         }
15820         return NDR_ERR_SUCCESS;
15821 }
15822
15823 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
15824 {
15825         ndr_print_struct(ndr, name, "spoolss_FormArea");
15826         ndr->depth++;
15827         ndr_print_uint32(ndr, "left", r->left);
15828         ndr_print_uint32(ndr, "top", r->top);
15829         ndr_print_uint32(ndr, "right", r->right);
15830         ndr_print_uint32(ndr, "bottom", r->bottom);
15831         ndr->depth--;
15832 }
15833
15834 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
15835 {
15836         if (ndr_flags & NDR_SCALARS) {
15837                 NDR_CHECK(ndr_push_align(ndr, 5));
15838                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15839                 {
15840                         uint32_t _flags_save_string = ndr->flags;
15841                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15842                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
15843                         ndr->flags = _flags_save_string;
15844                 }
15845                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15846                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15847                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15848         }
15849         if (ndr_flags & NDR_BUFFERS) {
15850                 {
15851                         uint32_t _flags_save_string = ndr->flags;
15852                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15853                         if (r->form_name) {
15854                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
15855                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
15856                         }
15857                         ndr->flags = _flags_save_string;
15858                 }
15859         }
15860         return NDR_ERR_SUCCESS;
15861 }
15862
15863 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
15864 {
15865         uint32_t _ptr_form_name;
15866         TALLOC_CTX *_mem_save_form_name_0;
15867         if (ndr_flags & NDR_SCALARS) {
15868                 NDR_CHECK(ndr_pull_align(ndr, 5));
15869                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15870                 {
15871                         uint32_t _flags_save_string = ndr->flags;
15872                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15873                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15874                         if (_ptr_form_name) {
15875                                 NDR_PULL_ALLOC(ndr, r->form_name);
15876                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15877                         } else {
15878                                 r->form_name = NULL;
15879                         }
15880                         ndr->flags = _flags_save_string;
15881                 }
15882                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15883                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15884                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15885         }
15886         if (ndr_flags & NDR_BUFFERS) {
15887                 {
15888                         uint32_t _flags_save_string = ndr->flags;
15889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15890                         if (r->form_name) {
15891                                 uint32_t _relative_save_offset;
15892                                 _relative_save_offset = ndr->offset;
15893                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15894                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15895                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15896                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15897                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15898                                 if (ndr->offset > ndr->relative_highest_offset) {
15899                                         ndr->relative_highest_offset = ndr->offset;
15900                                 }
15901                                 ndr->offset = _relative_save_offset;
15902                         }
15903                         ndr->flags = _flags_save_string;
15904                 }
15905         }
15906         return NDR_ERR_SUCCESS;
15907 }
15908
15909 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
15910 {
15911         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
15912         ndr->depth++;
15913         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15914         ndr_print_ptr(ndr, "form_name", r->form_name);
15915         ndr->depth++;
15916         if (r->form_name) {
15917                 ndr_print_string(ndr, "form_name", r->form_name);
15918         }
15919         ndr->depth--;
15920         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15921         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15922         ndr->depth--;
15923 }
15924
15925 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15926 {
15927         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
15928 }
15929
15930 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15931 {
15932         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15933         return NDR_ERR_SUCCESS;
15934 }
15935
15936 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15937 {
15938         uint32_t v;
15939         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15940         *r = v;
15941         return NDR_ERR_SUCCESS;
15942 }
15943
15944 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
15945 {
15946         ndr_print_uint32(ndr, name, r);
15947         ndr->depth++;
15948         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
15949         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
15950         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
15951         ndr->depth--;
15952 }
15953
15954 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
15955 {
15956         if (ndr_flags & NDR_SCALARS) {
15957                 NDR_CHECK(ndr_push_align(ndr, 5));
15958                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15959                 {
15960                         uint32_t _flags_save_string = ndr->flags;
15961                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15962                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
15963                         ndr->flags = _flags_save_string;
15964                 }
15965                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15966                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15967                 {
15968                         uint32_t _flags_save_string = ndr->flags;
15969                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15970                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
15971                         ndr->flags = _flags_save_string;
15972                 }
15973                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15974                 {
15975                         uint32_t _flags_save_string = ndr->flags;
15976                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15977                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
15978                         ndr->flags = _flags_save_string;
15979                 }
15980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15981                 {
15982                         uint32_t _flags_save_string = ndr->flags;
15983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15984                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
15985                         ndr->flags = _flags_save_string;
15986                 }
15987                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lang_id));
15988                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unused));
15989                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15990         }
15991         if (ndr_flags & NDR_BUFFERS) {
15992                 {
15993                         uint32_t _flags_save_string = ndr->flags;
15994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15995                         if (r->form_name) {
15996                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
15997                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
15998                         }
15999                         ndr->flags = _flags_save_string;
16000                 }
16001                 {
16002                         uint32_t _flags_save_string = ndr->flags;
16003                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16004                         if (r->keyword) {
16005                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
16006                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
16007                         }
16008                         ndr->flags = _flags_save_string;
16009                 }
16010                 {
16011                         uint32_t _flags_save_string = ndr->flags;
16012                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16013                         if (r->mui_dll) {
16014                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
16015                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
16016                         }
16017                         ndr->flags = _flags_save_string;
16018                 }
16019                 {
16020                         uint32_t _flags_save_string = ndr->flags;
16021                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16022                         if (r->display_name) {
16023                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
16024                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
16025                         }
16026                         ndr->flags = _flags_save_string;
16027                 }
16028         }
16029         return NDR_ERR_SUCCESS;
16030 }
16031
16032 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
16033 {
16034         uint32_t _ptr_form_name;
16035         TALLOC_CTX *_mem_save_form_name_0;
16036         uint32_t _ptr_keyword;
16037         TALLOC_CTX *_mem_save_keyword_0;
16038         uint32_t _ptr_mui_dll;
16039         TALLOC_CTX *_mem_save_mui_dll_0;
16040         uint32_t _ptr_display_name;
16041         TALLOC_CTX *_mem_save_display_name_0;
16042         if (ndr_flags & NDR_SCALARS) {
16043                 NDR_CHECK(ndr_pull_align(ndr, 5));
16044                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16045                 {
16046                         uint32_t _flags_save_string = ndr->flags;
16047                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16048                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16049                         if (_ptr_form_name) {
16050                                 NDR_PULL_ALLOC(ndr, r->form_name);
16051                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
16052                         } else {
16053                                 r->form_name = NULL;
16054                         }
16055                         ndr->flags = _flags_save_string;
16056                 }
16057                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16058                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16059                 {
16060                         uint32_t _flags_save_string = ndr->flags;
16061                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16062                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16063                         if (_ptr_keyword) {
16064                                 NDR_PULL_ALLOC(ndr, r->keyword);
16065                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
16066                         } else {
16067                                 r->keyword = NULL;
16068                         }
16069                         ndr->flags = _flags_save_string;
16070                 }
16071                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16072                 {
16073                         uint32_t _flags_save_string = ndr->flags;
16074                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16075                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16076                         if (_ptr_mui_dll) {
16077                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
16078                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
16079                         } else {
16080                                 r->mui_dll = NULL;
16081                         }
16082                         ndr->flags = _flags_save_string;
16083                 }
16084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16085                 {
16086                         uint32_t _flags_save_string = ndr->flags;
16087                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16088                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16089                         if (_ptr_display_name) {
16090                                 NDR_PULL_ALLOC(ndr, r->display_name);
16091                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
16092                         } else {
16093                                 r->display_name = NULL;
16094                         }
16095                         ndr->flags = _flags_save_string;
16096                 }
16097                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lang_id));
16098                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unused));
16099                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16100         }
16101         if (ndr_flags & NDR_BUFFERS) {
16102                 {
16103                         uint32_t _flags_save_string = ndr->flags;
16104                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16105                         if (r->form_name) {
16106                                 uint32_t _relative_save_offset;
16107                                 _relative_save_offset = ndr->offset;
16108                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
16109                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16110                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16111                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
16112                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16113                                 if (ndr->offset > ndr->relative_highest_offset) {
16114                                         ndr->relative_highest_offset = ndr->offset;
16115                                 }
16116                                 ndr->offset = _relative_save_offset;
16117                         }
16118                         ndr->flags = _flags_save_string;
16119                 }
16120                 {
16121                         uint32_t _flags_save_string = ndr->flags;
16122                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16123                         if (r->keyword) {
16124                                 uint32_t _relative_save_offset;
16125                                 _relative_save_offset = ndr->offset;
16126                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
16127                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16128                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16129                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
16130                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16131                                 if (ndr->offset > ndr->relative_highest_offset) {
16132                                         ndr->relative_highest_offset = ndr->offset;
16133                                 }
16134                                 ndr->offset = _relative_save_offset;
16135                         }
16136                         ndr->flags = _flags_save_string;
16137                 }
16138                 {
16139                         uint32_t _flags_save_string = ndr->flags;
16140                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16141                         if (r->mui_dll) {
16142                                 uint32_t _relative_save_offset;
16143                                 _relative_save_offset = ndr->offset;
16144                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
16145                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16146                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16147                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
16148                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16149                                 if (ndr->offset > ndr->relative_highest_offset) {
16150                                         ndr->relative_highest_offset = ndr->offset;
16151                                 }
16152                                 ndr->offset = _relative_save_offset;
16153                         }
16154                         ndr->flags = _flags_save_string;
16155                 }
16156                 {
16157                         uint32_t _flags_save_string = ndr->flags;
16158                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16159                         if (r->display_name) {
16160                                 uint32_t _relative_save_offset;
16161                                 _relative_save_offset = ndr->offset;
16162                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
16163                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16164                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16165                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
16166                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16167                                 if (ndr->offset > ndr->relative_highest_offset) {
16168                                         ndr->relative_highest_offset = ndr->offset;
16169                                 }
16170                                 ndr->offset = _relative_save_offset;
16171                         }
16172                         ndr->flags = _flags_save_string;
16173                 }
16174         }
16175         return NDR_ERR_SUCCESS;
16176 }
16177
16178 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
16179 {
16180         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
16181         ndr->depth++;
16182         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16183         ndr_print_ptr(ndr, "form_name", r->form_name);
16184         ndr->depth++;
16185         if (r->form_name) {
16186                 ndr_print_string(ndr, "form_name", r->form_name);
16187         }
16188         ndr->depth--;
16189         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16190         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16191         ndr_print_ptr(ndr, "keyword", r->keyword);
16192         ndr->depth++;
16193         if (r->keyword) {
16194                 ndr_print_string(ndr, "keyword", r->keyword);
16195         }
16196         ndr->depth--;
16197         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16198         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16199         ndr->depth++;
16200         if (r->mui_dll) {
16201                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16202         }
16203         ndr->depth--;
16204         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16205         ndr_print_ptr(ndr, "display_name", r->display_name);
16206         ndr->depth++;
16207         if (r->display_name) {
16208                 ndr_print_string(ndr, "display_name", r->display_name);
16209         }
16210         ndr->depth--;
16211         ndr_print_uint16(ndr, "lang_id", r->lang_id);
16212         ndr_print_uint16(ndr, "unused", r->unused);
16213         ndr->depth--;
16214 }
16215
16216 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16217 {
16218         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
16219 }
16220
16221 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
16222 {
16223         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16224         if (ndr_flags & NDR_SCALARS) {
16225                 int level = ndr_push_get_switch_value(ndr, r);
16226                 NDR_CHECK(ndr_push_union_align(ndr, 5));
16227                 switch (level) {
16228                         case 1: {
16229                                 NDR_CHECK(ndr_push_align(ndr, 5));
16230                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16231                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16232                         break; }
16233
16234                         case 2: {
16235                                 NDR_CHECK(ndr_push_align(ndr, 5));
16236                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16237                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16238                         break; }
16239
16240                         default: {
16241                         break; }
16242
16243                 }
16244         }
16245         if (ndr_flags & NDR_BUFFERS) {
16246                 int level = ndr_push_get_switch_value(ndr, r);
16247                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16248                 switch (level) {
16249                         case 1:
16250                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16251                         break;
16252
16253                         case 2:
16254                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16255                         break;
16256
16257                         default:
16258                         break;
16259
16260                 }
16261         }
16262         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16263         return NDR_ERR_SUCCESS;
16264 }
16265
16266 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
16267 {
16268         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16269         int level;
16270         level = ndr_pull_get_switch_value(ndr, r);
16271         if (ndr_flags & NDR_SCALARS) {
16272                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
16273                 switch (level) {
16274                         case 1: {
16275                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16276                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16277                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16278                         break; }
16279
16280                         case 2: {
16281                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16282                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16283                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16284                         break; }
16285
16286                         default: {
16287                         break; }
16288
16289                 }
16290         }
16291         if (ndr_flags & NDR_BUFFERS) {
16292                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16293                 switch (level) {
16294                         case 1:
16295                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16296                         break;
16297
16298                         case 2:
16299                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16300                         break;
16301
16302                         default:
16303                         break;
16304
16305                 }
16306         }
16307         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16308         return NDR_ERR_SUCCESS;
16309 }
16310
16311 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
16312 {
16313         int level;
16314         level = ndr_print_get_switch_value(ndr, r);
16315         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
16316         switch (level) {
16317                 case 1:
16318                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
16319                 break;
16320
16321                 case 2:
16322                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
16323                 break;
16324
16325                 default:
16326                 break;
16327
16328         }
16329 }
16330
16331 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
16332 {
16333         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
16334 }
16335
16336 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
16337 {
16338         if (ndr_flags & NDR_SCALARS) {
16339                 NDR_CHECK(ndr_push_align(ndr, 5));
16340                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16341                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
16342                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16343                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16344                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16345         }
16346         if (ndr_flags & NDR_BUFFERS) {
16347                 if (r->form_name) {
16348                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16349                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16350                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16351                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16352                 }
16353         }
16354         return NDR_ERR_SUCCESS;
16355 }
16356
16357 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
16358 {
16359         uint32_t _ptr_form_name;
16360         TALLOC_CTX *_mem_save_form_name_0;
16361         if (ndr_flags & NDR_SCALARS) {
16362                 NDR_CHECK(ndr_pull_align(ndr, 5));
16363                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16364                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16365                 if (_ptr_form_name) {
16366                         NDR_PULL_ALLOC(ndr, r->form_name);
16367                 } else {
16368                         r->form_name = NULL;
16369                 }
16370                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16371                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16372                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16373         }
16374         if (ndr_flags & NDR_BUFFERS) {
16375                 if (r->form_name) {
16376                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16377                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16378                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16379                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16380                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
16381                                 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));
16382                         }
16383                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
16384                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
16385                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16386                 }
16387         }
16388         return NDR_ERR_SUCCESS;
16389 }
16390
16391 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
16392 {
16393         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
16394         ndr->depth++;
16395         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16396         ndr_print_ptr(ndr, "form_name", r->form_name);
16397         ndr->depth++;
16398         if (r->form_name) {
16399                 ndr_print_string(ndr, "form_name", r->form_name);
16400         }
16401         ndr->depth--;
16402         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16403         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16404         ndr->depth--;
16405 }
16406
16407 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
16408 {
16409         if (ndr_flags & NDR_SCALARS) {
16410                 NDR_CHECK(ndr_push_align(ndr, 5));
16411                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16412                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
16413                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16414                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16415                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
16416                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
16417                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
16418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
16419                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
16420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
16421                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16422         }
16423         if (ndr_flags & NDR_BUFFERS) {
16424                 if (r->form_name) {
16425                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16426                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16427                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16428                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16429                 }
16430                 if (r->keyword) {
16431                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16432                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16433                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16434                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
16435                 }
16436                 if (r->mui_dll) {
16437                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16438                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16439                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16440                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16441                 }
16442                 if (r->display_name) {
16443                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16444                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16445                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16446                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16447                 }
16448         }
16449         return NDR_ERR_SUCCESS;
16450 }
16451
16452 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
16453 {
16454         uint32_t _ptr_form_name;
16455         TALLOC_CTX *_mem_save_form_name_0;
16456         uint32_t _ptr_keyword;
16457         TALLOC_CTX *_mem_save_keyword_0;
16458         uint32_t _ptr_mui_dll;
16459         TALLOC_CTX *_mem_save_mui_dll_0;
16460         uint32_t _ptr_display_name;
16461         TALLOC_CTX *_mem_save_display_name_0;
16462         if (ndr_flags & NDR_SCALARS) {
16463                 NDR_CHECK(ndr_pull_align(ndr, 5));
16464                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16465                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16466                 if (_ptr_form_name) {
16467                         NDR_PULL_ALLOC(ndr, r->form_name);
16468                 } else {
16469                         r->form_name = NULL;
16470                 }
16471                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16472                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16473                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16474                 if (_ptr_keyword) {
16475                         NDR_PULL_ALLOC(ndr, r->keyword);
16476                 } else {
16477                         r->keyword = NULL;
16478                 }
16479                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16480                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16481                 if (_ptr_mui_dll) {
16482                         NDR_PULL_ALLOC(ndr, r->mui_dll);
16483                 } else {
16484                         r->mui_dll = NULL;
16485                 }
16486                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16487                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16488                 if (_ptr_display_name) {
16489                         NDR_PULL_ALLOC(ndr, r->display_name);
16490                 } else {
16491                         r->display_name = NULL;
16492                 }
16493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
16494                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16495         }
16496         if (ndr_flags & NDR_BUFFERS) {
16497                 if (r->form_name) {
16498                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16499                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16500                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16501                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16502                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
16503                                 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));
16504                         }
16505                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
16506                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
16507                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16508                 }
16509                 if (r->keyword) {
16510                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16511                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16512                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
16513                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
16514                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
16515                                 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));
16516                         }
16517                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
16518                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
16519                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16520                 }
16521                 if (r->mui_dll) {
16522                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16523                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16524                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
16525                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
16526                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
16527                                 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));
16528                         }
16529                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
16530                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
16531                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16532                 }
16533                 if (r->display_name) {
16534                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16535                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16536                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
16537                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
16538                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
16539                                 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));
16540                         }
16541                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
16542                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
16543                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16544                 }
16545         }
16546         return NDR_ERR_SUCCESS;
16547 }
16548
16549 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
16550 {
16551         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
16552         ndr->depth++;
16553         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16554         ndr_print_ptr(ndr, "form_name", r->form_name);
16555         ndr->depth++;
16556         if (r->form_name) {
16557                 ndr_print_string(ndr, "form_name", r->form_name);
16558         }
16559         ndr->depth--;
16560         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16561         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16562         ndr_print_ptr(ndr, "keyword", r->keyword);
16563         ndr->depth++;
16564         if (r->keyword) {
16565                 ndr_print_string(ndr, "keyword", r->keyword);
16566         }
16567         ndr->depth--;
16568         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16569         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16570         ndr->depth++;
16571         if (r->mui_dll) {
16572                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16573         }
16574         ndr->depth--;
16575         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16576         ndr_print_ptr(ndr, "display_name", r->display_name);
16577         ndr->depth++;
16578         if (r->display_name) {
16579                 ndr_print_string(ndr, "display_name", r->display_name);
16580         }
16581         ndr->depth--;
16582         ndr_print_uint32(ndr, "lang_id", r->lang_id);
16583         ndr->depth--;
16584 }
16585
16586 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
16587 {
16588         if (ndr_flags & NDR_SCALARS) {
16589                 int level = ndr_push_get_switch_value(ndr, r);
16590                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
16591                 NDR_CHECK(ndr_push_union_align(ndr, 5));
16592                 switch (level) {
16593                         case 1: {
16594                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
16595                         break; }
16596
16597                         case 2: {
16598                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
16599                         break; }
16600
16601                         default:
16602                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16603                 }
16604         }
16605         if (ndr_flags & NDR_BUFFERS) {
16606                 int level = ndr_push_get_switch_value(ndr, r);
16607                 switch (level) {
16608                         case 1:
16609                                 if (r->info1) {
16610                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16611                                 }
16612                         break;
16613
16614                         case 2:
16615                                 if (r->info2) {
16616                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16617                                 }
16618                         break;
16619
16620                         default:
16621                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16622                 }
16623         }
16624         return NDR_ERR_SUCCESS;
16625 }
16626
16627 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
16628 {
16629         int level;
16630         uint32_t _level;
16631         TALLOC_CTX *_mem_save_info1_0;
16632         TALLOC_CTX *_mem_save_info2_0;
16633         level = ndr_pull_get_switch_value(ndr, r);
16634         if (ndr_flags & NDR_SCALARS) {
16635                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
16636                 if (_level != level) {
16637                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
16638                 }
16639                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
16640                 switch (level) {
16641                         case 1: {
16642                                 uint32_t _ptr_info1;
16643                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
16644                                 if (_ptr_info1) {
16645                                         NDR_PULL_ALLOC(ndr, r->info1);
16646                                 } else {
16647                                         r->info1 = NULL;
16648                                 }
16649                         break; }
16650
16651                         case 2: {
16652                                 uint32_t _ptr_info2;
16653                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
16654                                 if (_ptr_info2) {
16655                                         NDR_PULL_ALLOC(ndr, r->info2);
16656                                 } else {
16657                                         r->info2 = NULL;
16658                                 }
16659                         break; }
16660
16661                         default:
16662                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16663                 }
16664         }
16665         if (ndr_flags & NDR_BUFFERS) {
16666                 switch (level) {
16667                         case 1:
16668                                 if (r->info1) {
16669                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
16670                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
16671                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16672                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
16673                                 }
16674                         break;
16675
16676                         case 2:
16677                                 if (r->info2) {
16678                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
16679                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
16680                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16681                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
16682                                 }
16683                         break;
16684
16685                         default:
16686                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16687                 }
16688         }
16689         return NDR_ERR_SUCCESS;
16690 }
16691
16692 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
16693 {
16694         int level;
16695         level = ndr_print_get_switch_value(ndr, r);
16696         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
16697         switch (level) {
16698                 case 1:
16699                         ndr_print_ptr(ndr, "info1", r->info1);
16700                         ndr->depth++;
16701                         if (r->info1) {
16702                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
16703                         }
16704                         ndr->depth--;
16705                 break;
16706
16707                 case 2:
16708                         ndr_print_ptr(ndr, "info2", r->info2);
16709                         ndr->depth++;
16710                         if (r->info2) {
16711                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
16712                         }
16713                         ndr->depth--;
16714                 break;
16715
16716                 default:
16717                         ndr_print_bad_level(ndr, name, level);
16718         }
16719 }
16720
16721 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
16722 {
16723         if (ndr_flags & NDR_SCALARS) {
16724                 NDR_CHECK(ndr_push_align(ndr, 5));
16725                 {
16726                         uint32_t _flags_save_string = ndr->flags;
16727                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16728                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16729                         ndr->flags = _flags_save_string;
16730                 }
16731                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16732         }
16733         if (ndr_flags & NDR_BUFFERS) {
16734                 {
16735                         uint32_t _flags_save_string = ndr->flags;
16736                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16737                         if (r->port_name) {
16738                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16739                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16740                         }
16741                         ndr->flags = _flags_save_string;
16742                 }
16743         }
16744         return NDR_ERR_SUCCESS;
16745 }
16746
16747 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
16748 {
16749         uint32_t _ptr_port_name;
16750         TALLOC_CTX *_mem_save_port_name_0;
16751         if (ndr_flags & NDR_SCALARS) {
16752                 NDR_CHECK(ndr_pull_align(ndr, 5));
16753                 {
16754                         uint32_t _flags_save_string = ndr->flags;
16755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16756                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16757                         if (_ptr_port_name) {
16758                                 NDR_PULL_ALLOC(ndr, r->port_name);
16759                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16760                         } else {
16761                                 r->port_name = NULL;
16762                         }
16763                         ndr->flags = _flags_save_string;
16764                 }
16765                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16766         }
16767         if (ndr_flags & NDR_BUFFERS) {
16768                 {
16769                         uint32_t _flags_save_string = ndr->flags;
16770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16771                         if (r->port_name) {
16772                                 uint32_t _relative_save_offset;
16773                                 _relative_save_offset = ndr->offset;
16774                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16775                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16776                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16777                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16778                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16779                                 if (ndr->offset > ndr->relative_highest_offset) {
16780                                         ndr->relative_highest_offset = ndr->offset;
16781                                 }
16782                                 ndr->offset = _relative_save_offset;
16783                         }
16784                         ndr->flags = _flags_save_string;
16785                 }
16786         }
16787         return NDR_ERR_SUCCESS;
16788 }
16789
16790 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
16791 {
16792         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
16793         ndr->depth++;
16794         ndr_print_ptr(ndr, "port_name", r->port_name);
16795         ndr->depth++;
16796         if (r->port_name) {
16797                 ndr_print_string(ndr, "port_name", r->port_name);
16798         }
16799         ndr->depth--;
16800         ndr->depth--;
16801 }
16802
16803 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16804 {
16805         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
16806 }
16807
16808 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16809 {
16810         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16811         return NDR_ERR_SUCCESS;
16812 }
16813
16814 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16815 {
16816         uint32_t v;
16817         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16818         *r = v;
16819         return NDR_ERR_SUCCESS;
16820 }
16821
16822 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
16823 {
16824         ndr_print_uint32(ndr, name, r);
16825         ndr->depth++;
16826         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
16827         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
16828         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
16829         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
16830         ndr->depth--;
16831 }
16832
16833 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
16834 {
16835         if (ndr_flags & NDR_SCALARS) {
16836                 NDR_CHECK(ndr_push_align(ndr, 5));
16837                 {
16838                         uint32_t _flags_save_string = ndr->flags;
16839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16840                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16841                         ndr->flags = _flags_save_string;
16842                 }
16843                 {
16844                         uint32_t _flags_save_string = ndr->flags;
16845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16846                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16847                         ndr->flags = _flags_save_string;
16848                 }
16849                 {
16850                         uint32_t _flags_save_string = ndr->flags;
16851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16852                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
16853                         ndr->flags = _flags_save_string;
16854                 }
16855                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
16856                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
16857                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16858         }
16859         if (ndr_flags & NDR_BUFFERS) {
16860                 {
16861                         uint32_t _flags_save_string = ndr->flags;
16862                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16863                         if (r->port_name) {
16864                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16865                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16866                         }
16867                         ndr->flags = _flags_save_string;
16868                 }
16869                 {
16870                         uint32_t _flags_save_string = ndr->flags;
16871                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16872                         if (r->monitor_name) {
16873                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16874                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16875                         }
16876                         ndr->flags = _flags_save_string;
16877                 }
16878                 {
16879                         uint32_t _flags_save_string = ndr->flags;
16880                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16881                         if (r->description) {
16882                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
16883                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
16884                         }
16885                         ndr->flags = _flags_save_string;
16886                 }
16887         }
16888         return NDR_ERR_SUCCESS;
16889 }
16890
16891 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
16892 {
16893         uint32_t _ptr_port_name;
16894         TALLOC_CTX *_mem_save_port_name_0;
16895         uint32_t _ptr_monitor_name;
16896         TALLOC_CTX *_mem_save_monitor_name_0;
16897         uint32_t _ptr_description;
16898         TALLOC_CTX *_mem_save_description_0;
16899         if (ndr_flags & NDR_SCALARS) {
16900                 NDR_CHECK(ndr_pull_align(ndr, 5));
16901                 {
16902                         uint32_t _flags_save_string = ndr->flags;
16903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16904                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16905                         if (_ptr_port_name) {
16906                                 NDR_PULL_ALLOC(ndr, r->port_name);
16907                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16908                         } else {
16909                                 r->port_name = NULL;
16910                         }
16911                         ndr->flags = _flags_save_string;
16912                 }
16913                 {
16914                         uint32_t _flags_save_string = ndr->flags;
16915                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16916                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16917                         if (_ptr_monitor_name) {
16918                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16919                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16920                         } else {
16921                                 r->monitor_name = NULL;
16922                         }
16923                         ndr->flags = _flags_save_string;
16924                 }
16925                 {
16926                         uint32_t _flags_save_string = ndr->flags;
16927                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16928                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
16929                         if (_ptr_description) {
16930                                 NDR_PULL_ALLOC(ndr, r->description);
16931                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
16932                         } else {
16933                                 r->description = NULL;
16934                         }
16935                         ndr->flags = _flags_save_string;
16936                 }
16937                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
16938                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
16939                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16940         }
16941         if (ndr_flags & NDR_BUFFERS) {
16942                 {
16943                         uint32_t _flags_save_string = ndr->flags;
16944                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16945                         if (r->port_name) {
16946                                 uint32_t _relative_save_offset;
16947                                 _relative_save_offset = ndr->offset;
16948                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16949                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16950                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16951                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16952                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16953                                 if (ndr->offset > ndr->relative_highest_offset) {
16954                                         ndr->relative_highest_offset = ndr->offset;
16955                                 }
16956                                 ndr->offset = _relative_save_offset;
16957                         }
16958                         ndr->flags = _flags_save_string;
16959                 }
16960                 {
16961                         uint32_t _flags_save_string = ndr->flags;
16962                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16963                         if (r->monitor_name) {
16964                                 uint32_t _relative_save_offset;
16965                                 _relative_save_offset = ndr->offset;
16966                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16967                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16968                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16969                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16970                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16971                                 if (ndr->offset > ndr->relative_highest_offset) {
16972                                         ndr->relative_highest_offset = ndr->offset;
16973                                 }
16974                                 ndr->offset = _relative_save_offset;
16975                         }
16976                         ndr->flags = _flags_save_string;
16977                 }
16978                 {
16979                         uint32_t _flags_save_string = ndr->flags;
16980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16981                         if (r->description) {
16982                                 uint32_t _relative_save_offset;
16983                                 _relative_save_offset = ndr->offset;
16984                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
16985                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
16986                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
16987                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
16988                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
16989                                 if (ndr->offset > ndr->relative_highest_offset) {
16990                                         ndr->relative_highest_offset = ndr->offset;
16991                                 }
16992                                 ndr->offset = _relative_save_offset;
16993                         }
16994                         ndr->flags = _flags_save_string;
16995                 }
16996         }
16997         return NDR_ERR_SUCCESS;
16998 }
16999
17000 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
17001 {
17002         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
17003         ndr->depth++;
17004         ndr_print_ptr(ndr, "port_name", r->port_name);
17005         ndr->depth++;
17006         if (r->port_name) {
17007                 ndr_print_string(ndr, "port_name", r->port_name);
17008         }
17009         ndr->depth--;
17010         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17011         ndr->depth++;
17012         if (r->monitor_name) {
17013                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17014         }
17015         ndr->depth--;
17016         ndr_print_ptr(ndr, "description", r->description);
17017         ndr->depth++;
17018         if (r->description) {
17019                 ndr_print_string(ndr, "description", r->description);
17020         }
17021         ndr->depth--;
17022         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
17023         ndr_print_uint32(ndr, "reserved", r->reserved);
17024         ndr->depth--;
17025 }
17026
17027 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17028 {
17029         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
17030 }
17031
17032 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
17033 {
17034         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17035         return NDR_ERR_SUCCESS;
17036 }
17037
17038 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
17039 {
17040         uint32_t v;
17041         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17042         *r = v;
17043         return NDR_ERR_SUCCESS;
17044 }
17045
17046 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
17047 {
17048         const char *val = NULL;
17049
17050         switch (r) {
17051                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
17052                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
17053                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
17054                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
17055                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
17056                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
17057                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
17058                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
17059                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
17060                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
17061                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
17062                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
17063                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
17064         }
17065         ndr_print_enum(ndr, name, "ENUM", val, r);
17066 }
17067
17068 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
17069 {
17070         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17071         return NDR_ERR_SUCCESS;
17072 }
17073
17074 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
17075 {
17076         uint32_t v;
17077         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17078         *r = v;
17079         return NDR_ERR_SUCCESS;
17080 }
17081
17082 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
17083 {
17084         const char *val = NULL;
17085
17086         switch (r) {
17087                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
17088                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
17089                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
17090         }
17091         ndr_print_enum(ndr, name, "ENUM", val, r);
17092 }
17093
17094 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
17095 {
17096         if (ndr_flags & NDR_SCALARS) {
17097                 NDR_CHECK(ndr_push_align(ndr, 5));
17098                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
17099                 {
17100                         uint32_t _flags_save_string = ndr->flags;
17101                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17102                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
17103                         ndr->flags = _flags_save_string;
17104                 }
17105                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
17106                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17107         }
17108         if (ndr_flags & NDR_BUFFERS) {
17109                 {
17110                         uint32_t _flags_save_string = ndr->flags;
17111                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17112                         if (r->status_string) {
17113                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
17114                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
17115                         }
17116                         ndr->flags = _flags_save_string;
17117                 }
17118         }
17119         return NDR_ERR_SUCCESS;
17120 }
17121
17122 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
17123 {
17124         uint32_t _ptr_status_string;
17125         TALLOC_CTX *_mem_save_status_string_0;
17126         if (ndr_flags & NDR_SCALARS) {
17127                 NDR_CHECK(ndr_pull_align(ndr, 5));
17128                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
17129                 {
17130                         uint32_t _flags_save_string = ndr->flags;
17131                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17132                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
17133                         if (_ptr_status_string) {
17134                                 NDR_PULL_ALLOC(ndr, r->status_string);
17135                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
17136                         } else {
17137                                 r->status_string = NULL;
17138                         }
17139                         ndr->flags = _flags_save_string;
17140                 }
17141                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
17142                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17143         }
17144         if (ndr_flags & NDR_BUFFERS) {
17145                 {
17146                         uint32_t _flags_save_string = ndr->flags;
17147                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17148                         if (r->status_string) {
17149                                 uint32_t _relative_save_offset;
17150                                 _relative_save_offset = ndr->offset;
17151                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
17152                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17153                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
17154                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
17155                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
17156                                 if (ndr->offset > ndr->relative_highest_offset) {
17157                                         ndr->relative_highest_offset = ndr->offset;
17158                                 }
17159                                 ndr->offset = _relative_save_offset;
17160                         }
17161                         ndr->flags = _flags_save_string;
17162                 }
17163         }
17164         return NDR_ERR_SUCCESS;
17165 }
17166
17167 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
17168 {
17169         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
17170         ndr->depth++;
17171         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
17172         ndr_print_ptr(ndr, "status_string", r->status_string);
17173         ndr->depth++;
17174         if (r->status_string) {
17175                 ndr_print_string(ndr, "status_string", r->status_string);
17176         }
17177         ndr->depth--;
17178         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
17179         ndr->depth--;
17180 }
17181
17182 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
17183 {
17184         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
17185 }
17186
17187 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
17188 {
17189         if (ndr_flags & NDR_SCALARS) {
17190                 NDR_CHECK(ndr_push_align(ndr, 5));
17191                 {
17192                         uint32_t _flags_save_string = ndr->flags;
17193                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17194                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17195                         ndr->flags = _flags_save_string;
17196                 }
17197                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
17198                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17199         }
17200         if (ndr_flags & NDR_BUFFERS) {
17201                 {
17202                         uint32_t _flags_save_string = ndr->flags;
17203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17204                         if (r->port_name) {
17205                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
17206                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17207                         }
17208                         ndr->flags = _flags_save_string;
17209                 }
17210         }
17211         return NDR_ERR_SUCCESS;
17212 }
17213
17214 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
17215 {
17216         uint32_t _ptr_port_name;
17217         TALLOC_CTX *_mem_save_port_name_0;
17218         if (ndr_flags & NDR_SCALARS) {
17219                 NDR_CHECK(ndr_pull_align(ndr, 5));
17220                 {
17221                         uint32_t _flags_save_string = ndr->flags;
17222                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17223                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17224                         if (_ptr_port_name) {
17225                                 NDR_PULL_ALLOC(ndr, r->port_name);
17226                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17227                         } else {
17228                                 r->port_name = NULL;
17229                         }
17230                         ndr->flags = _flags_save_string;
17231                 }
17232                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
17233                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17234         }
17235         if (ndr_flags & NDR_BUFFERS) {
17236                 {
17237                         uint32_t _flags_save_string = ndr->flags;
17238                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17239                         if (r->port_name) {
17240                                 uint32_t _relative_save_offset;
17241                                 _relative_save_offset = ndr->offset;
17242                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17243                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17244                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17245                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17246                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17247                                 if (ndr->offset > ndr->relative_highest_offset) {
17248                                         ndr->relative_highest_offset = ndr->offset;
17249                                 }
17250                                 ndr->offset = _relative_save_offset;
17251                         }
17252                         ndr->flags = _flags_save_string;
17253                 }
17254         }
17255         return NDR_ERR_SUCCESS;
17256 }
17257
17258 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
17259 {
17260         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
17261         ndr->depth++;
17262         ndr_print_ptr(ndr, "port_name", r->port_name);
17263         ndr->depth++;
17264         if (r->port_name) {
17265                 ndr_print_string(ndr, "port_name", r->port_name);
17266         }
17267         ndr->depth--;
17268         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
17269         ndr->depth--;
17270 }
17271
17272 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
17273 {
17274         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
17275 }
17276
17277 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
17278 {
17279         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17280         if (ndr_flags & NDR_SCALARS) {
17281                 int level = ndr_push_get_switch_value(ndr, r);
17282                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17283                 switch (level) {
17284                         case 1: {
17285                                 NDR_CHECK(ndr_push_align(ndr, 5));
17286                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17287                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
17288                         break; }
17289
17290                         case 2: {
17291                                 NDR_CHECK(ndr_push_align(ndr, 5));
17292                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17293                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
17294                         break; }
17295
17296                         case 3: {
17297                                 NDR_CHECK(ndr_push_align(ndr, 5));
17298                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17299                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
17300                         break; }
17301
17302                         case 0xff: {
17303                                 NDR_CHECK(ndr_push_align(ndr, 5));
17304                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17305                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
17306                         break; }
17307
17308                         default: {
17309                         break; }
17310
17311                 }
17312         }
17313         if (ndr_flags & NDR_BUFFERS) {
17314                 int level = ndr_push_get_switch_value(ndr, r);
17315                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17316                 switch (level) {
17317                         case 1:
17318                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
17319                         break;
17320
17321                         case 2:
17322                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
17323                         break;
17324
17325                         case 3:
17326                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
17327                         break;
17328
17329                         case 0xff:
17330                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17331                         break;
17332
17333                         default:
17334                         break;
17335
17336                 }
17337         }
17338         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17339         return NDR_ERR_SUCCESS;
17340 }
17341
17342 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
17343 {
17344         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17345         int level;
17346         level = ndr_pull_get_switch_value(ndr, r);
17347         if (ndr_flags & NDR_SCALARS) {
17348                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17349                 switch (level) {
17350                         case 1: {
17351                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17352                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17353                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
17354                         break; }
17355
17356                         case 2: {
17357                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17358                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17359                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
17360                         break; }
17361
17362                         case 3: {
17363                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17364                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17365                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
17366                         break; }
17367
17368                         case 0xff: {
17369                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17370                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17371                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
17372                         break; }
17373
17374                         default: {
17375                         break; }
17376
17377                 }
17378         }
17379         if (ndr_flags & NDR_BUFFERS) {
17380                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17381                 switch (level) {
17382                         case 1:
17383                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
17384                         break;
17385
17386                         case 2:
17387                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
17388                         break;
17389
17390                         case 3:
17391                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
17392                         break;
17393
17394                         case 0xff:
17395                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17396                         break;
17397
17398                         default:
17399                         break;
17400
17401                 }
17402         }
17403         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17404         return NDR_ERR_SUCCESS;
17405 }
17406
17407 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
17408 {
17409         int level;
17410         level = ndr_print_get_switch_value(ndr, r);
17411         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
17412         switch (level) {
17413                 case 1:
17414                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
17415                 break;
17416
17417                 case 2:
17418                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
17419                 break;
17420
17421                 case 3:
17422                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
17423                 break;
17424
17425                 case 0xff:
17426                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
17427                 break;
17428
17429                 default:
17430                 break;
17431
17432         }
17433 }
17434
17435 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
17436 {
17437         if (ndr_flags & NDR_SCALARS) {
17438                 NDR_CHECK(ndr_push_align(ndr, 5));
17439                 {
17440                         uint32_t _flags_save_string = ndr->flags;
17441                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17442                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17443                         ndr->flags = _flags_save_string;
17444                 }
17445                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17446         }
17447         if (ndr_flags & NDR_BUFFERS) {
17448                 {
17449                         uint32_t _flags_save_string = ndr->flags;
17450                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17451                         if (r->monitor_name) {
17452                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
17453                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17454                         }
17455                         ndr->flags = _flags_save_string;
17456                 }
17457         }
17458         return NDR_ERR_SUCCESS;
17459 }
17460
17461 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
17462 {
17463         uint32_t _ptr_monitor_name;
17464         TALLOC_CTX *_mem_save_monitor_name_0;
17465         if (ndr_flags & NDR_SCALARS) {
17466                 NDR_CHECK(ndr_pull_align(ndr, 5));
17467                 {
17468                         uint32_t _flags_save_string = ndr->flags;
17469                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17470                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17471                         if (_ptr_monitor_name) {
17472                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17473                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17474                         } else {
17475                                 r->monitor_name = NULL;
17476                         }
17477                         ndr->flags = _flags_save_string;
17478                 }
17479                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17480         }
17481         if (ndr_flags & NDR_BUFFERS) {
17482                 {
17483                         uint32_t _flags_save_string = ndr->flags;
17484                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17485                         if (r->monitor_name) {
17486                                 uint32_t _relative_save_offset;
17487                                 _relative_save_offset = ndr->offset;
17488                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17489                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17490                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17491                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17492                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17493                                 if (ndr->offset > ndr->relative_highest_offset) {
17494                                         ndr->relative_highest_offset = ndr->offset;
17495                                 }
17496                                 ndr->offset = _relative_save_offset;
17497                         }
17498                         ndr->flags = _flags_save_string;
17499                 }
17500         }
17501         return NDR_ERR_SUCCESS;
17502 }
17503
17504 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
17505 {
17506         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
17507         ndr->depth++;
17508         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17509         ndr->depth++;
17510         if (r->monitor_name) {
17511                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17512         }
17513         ndr->depth--;
17514         ndr->depth--;
17515 }
17516
17517 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17518 {
17519         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
17520 }
17521
17522 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
17523 {
17524         if (ndr_flags & NDR_SCALARS) {
17525                 NDR_CHECK(ndr_push_align(ndr, 5));
17526                 {
17527                         uint32_t _flags_save_string = ndr->flags;
17528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17529                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17530                         ndr->flags = _flags_save_string;
17531                 }
17532                 {
17533                         uint32_t _flags_save_string = ndr->flags;
17534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17535                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
17536                         ndr->flags = _flags_save_string;
17537                 }
17538                 {
17539                         uint32_t _flags_save_string = ndr->flags;
17540                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17541                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
17542                         ndr->flags = _flags_save_string;
17543                 }
17544                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17545         }
17546         if (ndr_flags & NDR_BUFFERS) {
17547                 {
17548                         uint32_t _flags_save_string = ndr->flags;
17549                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17550                         if (r->monitor_name) {
17551                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
17552                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17553                         }
17554                         ndr->flags = _flags_save_string;
17555                 }
17556                 {
17557                         uint32_t _flags_save_string = ndr->flags;
17558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17559                         if (r->environment) {
17560                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
17561                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
17562                         }
17563                         ndr->flags = _flags_save_string;
17564                 }
17565                 {
17566                         uint32_t _flags_save_string = ndr->flags;
17567                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17568                         if (r->dll_name) {
17569                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
17570                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
17571                         }
17572                         ndr->flags = _flags_save_string;
17573                 }
17574         }
17575         return NDR_ERR_SUCCESS;
17576 }
17577
17578 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
17579 {
17580         uint32_t _ptr_monitor_name;
17581         TALLOC_CTX *_mem_save_monitor_name_0;
17582         uint32_t _ptr_environment;
17583         TALLOC_CTX *_mem_save_environment_0;
17584         uint32_t _ptr_dll_name;
17585         TALLOC_CTX *_mem_save_dll_name_0;
17586         if (ndr_flags & NDR_SCALARS) {
17587                 NDR_CHECK(ndr_pull_align(ndr, 5));
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_monitor_name));
17592                         if (_ptr_monitor_name) {
17593                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17594                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17595                         } else {
17596                                 r->monitor_name = NULL;
17597                         }
17598                         ndr->flags = _flags_save_string;
17599                 }
17600                 {
17601                         uint32_t _flags_save_string = ndr->flags;
17602                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17603                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
17604                         if (_ptr_environment) {
17605                                 NDR_PULL_ALLOC(ndr, r->environment);
17606                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
17607                         } else {
17608                                 r->environment = NULL;
17609                         }
17610                         ndr->flags = _flags_save_string;
17611                 }
17612                 {
17613                         uint32_t _flags_save_string = ndr->flags;
17614                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17615                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
17616                         if (_ptr_dll_name) {
17617                                 NDR_PULL_ALLOC(ndr, r->dll_name);
17618                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
17619                         } else {
17620                                 r->dll_name = NULL;
17621                         }
17622                         ndr->flags = _flags_save_string;
17623                 }
17624                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17625         }
17626         if (ndr_flags & NDR_BUFFERS) {
17627                 {
17628                         uint32_t _flags_save_string = ndr->flags;
17629                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17630                         if (r->monitor_name) {
17631                                 uint32_t _relative_save_offset;
17632                                 _relative_save_offset = ndr->offset;
17633                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17634                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17635                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17636                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17637                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17638                                 if (ndr->offset > ndr->relative_highest_offset) {
17639                                         ndr->relative_highest_offset = ndr->offset;
17640                                 }
17641                                 ndr->offset = _relative_save_offset;
17642                         }
17643                         ndr->flags = _flags_save_string;
17644                 }
17645                 {
17646                         uint32_t _flags_save_string = ndr->flags;
17647                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17648                         if (r->environment) {
17649                                 uint32_t _relative_save_offset;
17650                                 _relative_save_offset = ndr->offset;
17651                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
17652                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
17653                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
17654                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
17655                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
17656                                 if (ndr->offset > ndr->relative_highest_offset) {
17657                                         ndr->relative_highest_offset = ndr->offset;
17658                                 }
17659                                 ndr->offset = _relative_save_offset;
17660                         }
17661                         ndr->flags = _flags_save_string;
17662                 }
17663                 {
17664                         uint32_t _flags_save_string = ndr->flags;
17665                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17666                         if (r->dll_name) {
17667                                 uint32_t _relative_save_offset;
17668                                 _relative_save_offset = ndr->offset;
17669                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
17670                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17671                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
17672                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
17673                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
17674                                 if (ndr->offset > ndr->relative_highest_offset) {
17675                                         ndr->relative_highest_offset = ndr->offset;
17676                                 }
17677                                 ndr->offset = _relative_save_offset;
17678                         }
17679                         ndr->flags = _flags_save_string;
17680                 }
17681         }
17682         return NDR_ERR_SUCCESS;
17683 }
17684
17685 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
17686 {
17687         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
17688         ndr->depth++;
17689         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17690         ndr->depth++;
17691         if (r->monitor_name) {
17692                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17693         }
17694         ndr->depth--;
17695         ndr_print_ptr(ndr, "environment", r->environment);
17696         ndr->depth++;
17697         if (r->environment) {
17698                 ndr_print_string(ndr, "environment", r->environment);
17699         }
17700         ndr->depth--;
17701         ndr_print_ptr(ndr, "dll_name", r->dll_name);
17702         ndr->depth++;
17703         if (r->dll_name) {
17704                 ndr_print_string(ndr, "dll_name", r->dll_name);
17705         }
17706         ndr->depth--;
17707         ndr->depth--;
17708 }
17709
17710 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17711 {
17712         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
17713 }
17714
17715 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
17716 {
17717         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17718         if (ndr_flags & NDR_SCALARS) {
17719                 int level = ndr_push_get_switch_value(ndr, r);
17720                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17721                 switch (level) {
17722                         case 1: {
17723                                 NDR_CHECK(ndr_push_align(ndr, 5));
17724                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17725                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17726                         break; }
17727
17728                         case 2: {
17729                                 NDR_CHECK(ndr_push_align(ndr, 5));
17730                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17731                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17732                         break; }
17733
17734                         default: {
17735                         break; }
17736
17737                 }
17738         }
17739         if (ndr_flags & NDR_BUFFERS) {
17740                 int level = ndr_push_get_switch_value(ndr, r);
17741                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17742                 switch (level) {
17743                         case 1:
17744                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
17745                         break;
17746
17747                         case 2:
17748                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
17749                         break;
17750
17751                         default:
17752                         break;
17753
17754                 }
17755         }
17756         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17757         return NDR_ERR_SUCCESS;
17758 }
17759
17760 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
17761 {
17762         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17763         int level;
17764         level = ndr_pull_get_switch_value(ndr, r);
17765         if (ndr_flags & NDR_SCALARS) {
17766                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17767                 switch (level) {
17768                         case 1: {
17769                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17770                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17771                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17772                         break; }
17773
17774                         case 2: {
17775                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17776                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17777                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17778                         break; }
17779
17780                         default: {
17781                         break; }
17782
17783                 }
17784         }
17785         if (ndr_flags & NDR_BUFFERS) {
17786                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17787                 switch (level) {
17788                         case 1:
17789                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
17790                         break;
17791
17792                         case 2:
17793                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
17794                         break;
17795
17796                         default:
17797                         break;
17798
17799                 }
17800         }
17801         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17802         return NDR_ERR_SUCCESS;
17803 }
17804
17805 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
17806 {
17807         int level;
17808         level = ndr_print_get_switch_value(ndr, r);
17809         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
17810         switch (level) {
17811                 case 1:
17812                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
17813                 break;
17814
17815                 case 2:
17816                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
17817                 break;
17818
17819                 default:
17820                 break;
17821
17822         }
17823 }
17824
17825 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
17826 {
17827         if (ndr_flags & NDR_SCALARS) {
17828                 NDR_CHECK(ndr_push_align(ndr, 5));
17829                 {
17830                         uint32_t _flags_save_string = ndr->flags;
17831                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17832                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
17833                         ndr->flags = _flags_save_string;
17834                 }
17835                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17836         }
17837         if (ndr_flags & NDR_BUFFERS) {
17838                 {
17839                         uint32_t _flags_save_string = ndr->flags;
17840                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17841                         if (r->name_array) {
17842                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name_array));
17843                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
17844                         }
17845                         ndr->flags = _flags_save_string;
17846                 }
17847         }
17848         return NDR_ERR_SUCCESS;
17849 }
17850
17851 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
17852 {
17853         uint32_t _ptr_name_array;
17854         TALLOC_CTX *_mem_save_name_array_0;
17855         if (ndr_flags & NDR_SCALARS) {
17856                 NDR_CHECK(ndr_pull_align(ndr, 5));
17857                 {
17858                         uint32_t _flags_save_string = ndr->flags;
17859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17860                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
17861                         if (_ptr_name_array) {
17862                                 NDR_PULL_ALLOC(ndr, r->name_array);
17863                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
17864                         } else {
17865                                 r->name_array = NULL;
17866                         }
17867                         ndr->flags = _flags_save_string;
17868                 }
17869                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17870         }
17871         if (ndr_flags & NDR_BUFFERS) {
17872                 {
17873                         uint32_t _flags_save_string = ndr->flags;
17874                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17875                         if (r->name_array) {
17876                                 uint32_t _relative_save_offset;
17877                                 _relative_save_offset = ndr->offset;
17878                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
17879                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
17880                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
17881                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
17882                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
17883                                 if (ndr->offset > ndr->relative_highest_offset) {
17884                                         ndr->relative_highest_offset = ndr->offset;
17885                                 }
17886                                 ndr->offset = _relative_save_offset;
17887                         }
17888                         ndr->flags = _flags_save_string;
17889                 }
17890         }
17891         return NDR_ERR_SUCCESS;
17892 }
17893
17894 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
17895 {
17896         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
17897         ndr->depth++;
17898         ndr_print_ptr(ndr, "name_array", r->name_array);
17899         ndr->depth++;
17900         if (r->name_array) {
17901                 ndr_print_string(ndr, "name_array", r->name_array);
17902         }
17903         ndr->depth--;
17904         ndr->depth--;
17905 }
17906
17907 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17908 {
17909         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
17910 }
17911
17912 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
17913 {
17914         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17915         if (ndr_flags & NDR_SCALARS) {
17916                 int level = ndr_push_get_switch_value(ndr, r);
17917                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17918                 switch (level) {
17919                         case 1: {
17920                                 NDR_CHECK(ndr_push_align(ndr, 5));
17921                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17922                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
17923                         break; }
17924
17925                         default: {
17926                         break; }
17927
17928                 }
17929         }
17930         if (ndr_flags & NDR_BUFFERS) {
17931                 int level = ndr_push_get_switch_value(ndr, r);
17932                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17933                 switch (level) {
17934                         case 1:
17935                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
17936                         break;
17937
17938                         default:
17939                         break;
17940
17941                 }
17942         }
17943         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17944         return NDR_ERR_SUCCESS;
17945 }
17946
17947 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
17948 {
17949         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17950         int level;
17951         level = ndr_pull_get_switch_value(ndr, r);
17952         if (ndr_flags & NDR_SCALARS) {
17953                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17954                 switch (level) {
17955                         case 1: {
17956                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17957                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17958                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
17959                         break; }
17960
17961                         default: {
17962                         break; }
17963
17964                 }
17965         }
17966         if (ndr_flags & NDR_BUFFERS) {
17967                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17968                 switch (level) {
17969                         case 1:
17970                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
17971                         break;
17972
17973                         default:
17974                         break;
17975
17976                 }
17977         }
17978         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17979         return NDR_ERR_SUCCESS;
17980 }
17981
17982 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
17983 {
17984         int level;
17985         level = ndr_print_get_switch_value(ndr, r);
17986         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
17987         switch (level) {
17988                 case 1:
17989                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
17990                 break;
17991
17992                 default:
17993                 break;
17994
17995         }
17996 }
17997
17998 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17999 {
18000         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18001         return NDR_ERR_SUCCESS;
18002 }
18003
18004 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18005 {
18006         uint32_t v;
18007         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18008         *r = v;
18009         return NDR_ERR_SUCCESS;
18010 }
18011
18012 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18013 {
18014         ndr_print_uint32(ndr, name, r);
18015         ndr->depth++;
18016         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
18017         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
18018         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
18019         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
18020         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
18021         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
18022         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
18023         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
18024         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
18025         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
18026         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
18027         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
18028         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
18029         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
18030         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
18031         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
18032         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
18033         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
18034         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
18035         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
18036         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
18037         ndr->depth--;
18038 }
18039
18040 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobNotifyField r)
18041 {
18042         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18043         return NDR_ERR_SUCCESS;
18044 }
18045
18046 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobNotifyField *r)
18047 {
18048         uint16_t v;
18049         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18050         *r = v;
18051         return NDR_ERR_SUCCESS;
18052 }
18053
18054 _PUBLIC_ void ndr_print_spoolss_JobNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_JobNotifyField r)
18055 {
18056         const char *val = NULL;
18057
18058         switch (r) {
18059                 case JOB_NOTIFY_FIELD_PRINTER_NAME: val = "JOB_NOTIFY_FIELD_PRINTER_NAME"; break;
18060                 case JOB_NOTIFY_FIELD_MACHINE_NAME: val = "JOB_NOTIFY_FIELD_MACHINE_NAME"; break;
18061                 case JOB_NOTIFY_FIELD_PORT_NAME: val = "JOB_NOTIFY_FIELD_PORT_NAME"; break;
18062                 case JOB_NOTIFY_FIELD_USER_NAME: val = "JOB_NOTIFY_FIELD_USER_NAME"; break;
18063                 case JOB_NOTIFY_FIELD_NOTIFY_NAME: val = "JOB_NOTIFY_FIELD_NOTIFY_NAME"; break;
18064                 case JOB_NOTIFY_FIELD_DATATYPE: val = "JOB_NOTIFY_FIELD_DATATYPE"; break;
18065                 case JOB_NOTIFY_FIELD_PRINT_PROCESSOR: val = "JOB_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18066                 case JOB_NOTIFY_FIELD_PARAMETERS: val = "JOB_NOTIFY_FIELD_PARAMETERS"; break;
18067                 case JOB_NOTIFY_FIELD_DRIVER_NAME: val = "JOB_NOTIFY_FIELD_DRIVER_NAME"; break;
18068                 case JOB_NOTIFY_FIELD_DEVMODE: val = "JOB_NOTIFY_FIELD_DEVMODE"; break;
18069                 case JOB_NOTIFY_FIELD_STATUS: val = "JOB_NOTIFY_FIELD_STATUS"; break;
18070                 case JOB_NOTIFY_FIELD_STATUS_STRING: val = "JOB_NOTIFY_FIELD_STATUS_STRING"; break;
18071                 case JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18072                 case JOB_NOTIFY_FIELD_DOCUMENT: val = "JOB_NOTIFY_FIELD_DOCUMENT"; break;
18073                 case JOB_NOTIFY_FIELD_PRIORITY: val = "JOB_NOTIFY_FIELD_PRIORITY"; break;
18074                 case JOB_NOTIFY_FIELD_POSITION: val = "JOB_NOTIFY_FIELD_POSITION"; break;
18075                 case JOB_NOTIFY_FIELD_SUBMITTED: val = "JOB_NOTIFY_FIELD_SUBMITTED"; break;
18076                 case JOB_NOTIFY_FIELD_START_TIME: val = "JOB_NOTIFY_FIELD_START_TIME"; break;
18077                 case JOB_NOTIFY_FIELD_UNTIL_TIME: val = "JOB_NOTIFY_FIELD_UNTIL_TIME"; break;
18078                 case JOB_NOTIFY_FIELD_TIME: val = "JOB_NOTIFY_FIELD_TIME"; break;
18079                 case JOB_NOTIFY_FIELD_TOTAL_PAGES: val = "JOB_NOTIFY_FIELD_TOTAL_PAGES"; break;
18080                 case JOB_NOTIFY_FIELD_PAGES_PRINTED: val = "JOB_NOTIFY_FIELD_PAGES_PRINTED"; break;
18081                 case JOB_NOTIFY_FIELD_TOTAL_BYTES: val = "JOB_NOTIFY_FIELD_TOTAL_BYTES"; break;
18082                 case JOB_NOTIFY_FIELD_BYTES_PRINTED: val = "JOB_NOTIFY_FIELD_BYTES_PRINTED"; break;
18083         }
18084         ndr_print_enum(ndr, name, "ENUM", val, r);
18085 }
18086
18087 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrintNotifyField r)
18088 {
18089         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18090         return NDR_ERR_SUCCESS;
18091 }
18092
18093 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrintNotifyField *r)
18094 {
18095         uint16_t v;
18096         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18097         *r = v;
18098         return NDR_ERR_SUCCESS;
18099 }
18100
18101 _PUBLIC_ void ndr_print_spoolss_PrintNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_PrintNotifyField r)
18102 {
18103         const char *val = NULL;
18104
18105         switch (r) {
18106                 case PRINTER_NOTIFY_FIELD_SERVER_NAME: val = "PRINTER_NOTIFY_FIELD_SERVER_NAME"; break;
18107                 case PRINTER_NOTIFY_FIELD_PRINTER_NAME: val = "PRINTER_NOTIFY_FIELD_PRINTER_NAME"; break;
18108                 case PRINTER_NOTIFY_FIELD_SHARE_NAME: val = "PRINTER_NOTIFY_FIELD_SHARE_NAME"; break;
18109                 case PRINTER_NOTIFY_FIELD_PORT_NAME: val = "PRINTER_NOTIFY_FIELD_PORT_NAME"; break;
18110                 case PRINTER_NOTIFY_FIELD_DRIVER_NAME: val = "PRINTER_NOTIFY_FIELD_DRIVER_NAME"; break;
18111                 case PRINTER_NOTIFY_FIELD_COMMENT: val = "PRINTER_NOTIFY_FIELD_COMMENT"; break;
18112                 case PRINTER_NOTIFY_FIELD_LOCATION: val = "PRINTER_NOTIFY_FIELD_LOCATION"; break;
18113                 case PRINTER_NOTIFY_FIELD_DEVMODE: val = "PRINTER_NOTIFY_FIELD_DEVMODE"; break;
18114                 case PRINTER_NOTIFY_FIELD_SEPFILE: val = "PRINTER_NOTIFY_FIELD_SEPFILE"; break;
18115                 case PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: val = "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18116                 case PRINTER_NOTIFY_FIELD_PARAMETERS: val = "PRINTER_NOTIFY_FIELD_PARAMETERS"; break;
18117                 case PRINTER_NOTIFY_FIELD_DATATYPE: val = "PRINTER_NOTIFY_FIELD_DATATYPE"; break;
18118                 case PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18119                 case PRINTER_NOTIFY_FIELD_ATTRIBUTES: val = "PRINTER_NOTIFY_FIELD_ATTRIBUTES"; break;
18120                 case PRINTER_NOTIFY_FIELD_PRIORITY: val = "PRINTER_NOTIFY_FIELD_PRIORITY"; break;
18121                 case PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: val = "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY"; break;
18122                 case PRINTER_NOTIFY_FIELD_START_TIME: val = "PRINTER_NOTIFY_FIELD_START_TIME"; break;
18123                 case PRINTER_NOTIFY_FIELD_UNTIL_TIME: val = "PRINTER_NOTIFY_FIELD_UNTIL_TIME"; break;
18124                 case PRINTER_NOTIFY_FIELD_STATUS: val = "PRINTER_NOTIFY_FIELD_STATUS"; break;
18125                 case PRINTER_NOTIFY_FIELD_STATUS_STRING: val = "PRINTER_NOTIFY_FIELD_STATUS_STRING"; break;
18126                 case PRINTER_NOTIFY_FIELD_CJOBS: val = "PRINTER_NOTIFY_FIELD_CJOBS"; break;
18127                 case PRINTER_NOTIFY_FIELD_AVERAGE_PPM: val = "PRINTER_NOTIFY_FIELD_AVERAGE_PPM"; break;
18128                 case PRINTER_NOTIFY_FIELD_TOTAL_PAGES: val = "PRINTER_NOTIFY_FIELD_TOTAL_PAGES"; break;
18129                 case PRINTER_NOTIFY_FIELD_PAGES_PRINTED: val = "PRINTER_NOTIFY_FIELD_PAGES_PRINTED"; break;
18130                 case PRINTER_NOTIFY_FIELD_TOTAL_BYTES: val = "PRINTER_NOTIFY_FIELD_TOTAL_BYTES"; break;
18131                 case PRINTER_NOTIFY_FIELD_BYTES_PRINTED: val = "PRINTER_NOTIFY_FIELD_BYTES_PRINTED"; break;
18132                 case PRINTER_NOTIFY_FIELD_OBJECT_GUID: val = "PRINTER_NOTIFY_FIELD_OBJECT_GUID"; break;
18133                 case PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: val = "PRINTER_NOTIFY_FIELD_FRIENDLY_NAME"; break;
18134         }
18135         ndr_print_enum(ndr, name, "ENUM", val, r);
18136 }
18137
18138 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
18139 {
18140         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18141         return NDR_ERR_SUCCESS;
18142 }
18143
18144 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
18145 {
18146         uint16_t v;
18147         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18148         *r = v;
18149         return NDR_ERR_SUCCESS;
18150 }
18151
18152 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
18153 {
18154         const char *val = NULL;
18155
18156         switch (r) {
18157                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
18158                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
18159         }
18160         ndr_print_enum(ndr, name, "ENUM", val, r);
18161 }
18162
18163 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, const union spoolss_Field *r)
18164 {
18165         if (ndr_flags & NDR_SCALARS) {
18166                 int level = ndr_push_get_switch_value(ndr, r);
18167                 NDR_CHECK(ndr_push_union_align(ndr, 2));
18168                 switch (level) {
18169                         case PRINTER_NOTIFY_TYPE: {
18170                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18171                         break; }
18172
18173                         case JOB_NOTIFY_TYPE: {
18174                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18175                         break; }
18176
18177                         default: {
18178                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18179                         break; }
18180
18181                 }
18182         }
18183         if (ndr_flags & NDR_BUFFERS) {
18184                 int level = ndr_push_get_switch_value(ndr, r);
18185                 switch (level) {
18186                         case PRINTER_NOTIFY_TYPE:
18187                         break;
18188
18189                         case JOB_NOTIFY_TYPE:
18190                         break;
18191
18192                         default:
18193                         break;
18194
18195                 }
18196         }
18197         return NDR_ERR_SUCCESS;
18198 }
18199
18200 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, union spoolss_Field *r)
18201 {
18202         int level;
18203         level = ndr_pull_get_switch_value(ndr, r);
18204         if (ndr_flags & NDR_SCALARS) {
18205                 NDR_CHECK(ndr_pull_union_align(ndr, 2));
18206                 switch (level) {
18207                         case PRINTER_NOTIFY_TYPE: {
18208                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18209                         break; }
18210
18211                         case JOB_NOTIFY_TYPE: {
18212                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18213                         break; }
18214
18215                         default: {
18216                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18217                         break; }
18218
18219                 }
18220         }
18221         if (ndr_flags & NDR_BUFFERS) {
18222                 switch (level) {
18223                         case PRINTER_NOTIFY_TYPE:
18224                         break;
18225
18226                         case JOB_NOTIFY_TYPE:
18227                         break;
18228
18229                         default:
18230                         break;
18231
18232                 }
18233         }
18234         return NDR_ERR_SUCCESS;
18235 }
18236
18237 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
18238 {
18239         uint32_t cntr_fields_1;
18240         if (ndr_flags & NDR_SCALARS) {
18241                 NDR_CHECK(ndr_push_align(ndr, 5));
18242                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18243                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
18244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
18245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
18246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18247                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
18248                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18249         }
18250         if (ndr_flags & NDR_BUFFERS) {
18251                 if (r->fields) {
18252                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18253                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
18254                                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
18255                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
18256                         }
18257                 }
18258         }
18259         return NDR_ERR_SUCCESS;
18260 }
18261
18262 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
18263 {
18264         uint32_t _ptr_fields;
18265         uint32_t cntr_fields_1;
18266         TALLOC_CTX *_mem_save_fields_0;
18267         TALLOC_CTX *_mem_save_fields_1;
18268         if (ndr_flags & NDR_SCALARS) {
18269                 NDR_CHECK(ndr_pull_align(ndr, 5));
18270                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18271                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
18272                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
18273                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
18274                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18275                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
18276                 if (_ptr_fields) {
18277                         NDR_PULL_ALLOC(ndr, r->fields);
18278                 } else {
18279                         r->fields = NULL;
18280                 }
18281                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18282         }
18283         if (ndr_flags & NDR_BUFFERS) {
18284                 if (r->fields) {
18285                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
18286                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
18287                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
18288                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
18289                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
18290                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
18291                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
18292                                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
18293                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
18294                         }
18295                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
18296                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
18297                 }
18298                 if (r->fields) {
18299                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
18300                 }
18301         }
18302         return NDR_ERR_SUCCESS;
18303 }
18304
18305 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
18306 {
18307         uint32_t cntr_fields_1;
18308         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
18309         ndr->depth++;
18310         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
18311         ndr_print_uint16(ndr, "u1", r->u1);
18312         ndr_print_uint32(ndr, "u2", r->u2);
18313         ndr_print_uint32(ndr, "u3", r->u3);
18314         ndr_print_uint32(ndr, "count", r->count);
18315         ndr_print_ptr(ndr, "fields", r->fields);
18316         ndr->depth++;
18317         if (r->fields) {
18318                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
18319                 ndr->depth++;
18320                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
18321                         char *idx_1=NULL;
18322                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
18323                                 ndr_print_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type);
18324                                 ndr_print_spoolss_Field(ndr, "fields", &r->fields[cntr_fields_1]);
18325                                 free(idx_1);
18326                         }
18327                 }
18328                 ndr->depth--;
18329         }
18330         ndr->depth--;
18331         ndr->depth--;
18332 }
18333
18334 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18335 {
18336         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18337         return NDR_ERR_SUCCESS;
18338 }
18339
18340 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18341 {
18342         uint32_t v;
18343         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18344         *r = v;
18345         return NDR_ERR_SUCCESS;
18346 }
18347
18348 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18349 {
18350         ndr_print_uint32(ndr, name, r);
18351         ndr->depth++;
18352         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
18353         ndr->depth--;
18354 }
18355
18356 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
18357 {
18358         uint32_t cntr_types_1;
18359         if (ndr_flags & NDR_SCALARS) {
18360                 NDR_CHECK(ndr_push_align(ndr, 5));
18361                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
18362                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
18363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18364                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
18365                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18366         }
18367         if (ndr_flags & NDR_BUFFERS) {
18368                 if (r->types) {
18369                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18370                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18371                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
18372                         }
18373                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18374                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
18375                         }
18376                 }
18377         }
18378         return NDR_ERR_SUCCESS;
18379 }
18380
18381 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
18382 {
18383         uint32_t _ptr_types;
18384         uint32_t cntr_types_1;
18385         TALLOC_CTX *_mem_save_types_0;
18386         TALLOC_CTX *_mem_save_types_1;
18387         if (ndr_flags & NDR_SCALARS) {
18388                 NDR_CHECK(ndr_pull_align(ndr, 5));
18389                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18390                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
18391                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18392                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
18393                 if (_ptr_types) {
18394                         NDR_PULL_ALLOC(ndr, r->types);
18395                 } else {
18396                         r->types = NULL;
18397                 }
18398                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18399         }
18400         if (ndr_flags & NDR_BUFFERS) {
18401                 if (r->types) {
18402                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
18403                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
18404                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
18405                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
18406                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
18407                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
18408                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18409                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
18410                         }
18411                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18412                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
18413                         }
18414                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
18415                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
18416                 }
18417                 if (r->types) {
18418                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
18419                 }
18420         }
18421         return NDR_ERR_SUCCESS;
18422 }
18423
18424 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
18425 {
18426         uint32_t cntr_types_1;
18427         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
18428         ndr->depth++;
18429         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
18430         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
18431         ndr_print_uint32(ndr, "count", r->count);
18432         ndr_print_ptr(ndr, "types", r->types);
18433         ndr->depth++;
18434         if (r->types) {
18435                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
18436                 ndr->depth++;
18437                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
18438                         char *idx_1=NULL;
18439                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
18440                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
18441                                 free(idx_1);
18442                         }
18443                 }
18444                 ndr->depth--;
18445         }
18446         ndr->depth--;
18447         ndr->depth--;
18448 }
18449
18450 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
18451 {
18452         if (ndr_flags & NDR_SCALARS) {
18453                 NDR_CHECK(ndr_push_align(ndr, 5));
18454                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18455                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
18456                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18457         }
18458         if (ndr_flags & NDR_BUFFERS) {
18459                 if (r->string) {
18460                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size / 2));
18461                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
18462                 }
18463         }
18464         return NDR_ERR_SUCCESS;
18465 }
18466
18467 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
18468 {
18469         uint32_t _ptr_string;
18470         TALLOC_CTX *_mem_save_string_0;
18471         if (ndr_flags & NDR_SCALARS) {
18472                 NDR_CHECK(ndr_pull_align(ndr, 5));
18473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18474                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
18475                 if (_ptr_string) {
18476                         NDR_PULL_ALLOC(ndr, r->string);
18477                 } else {
18478                         r->string = NULL;
18479                 }
18480                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18481         }
18482         if (ndr_flags & NDR_BUFFERS) {
18483                 if (r->string) {
18484                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
18485                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
18486                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
18487                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
18488                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
18489                 }
18490                 if (r->string) {
18491                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
18492                 }
18493         }
18494         return NDR_ERR_SUCCESS;
18495 }
18496
18497 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
18498 {
18499         ndr_print_struct(ndr, name, "spoolss_NotifyString");
18500         ndr->depth++;
18501         ndr_print_uint32(ndr, "size", r->size);
18502         ndr_print_ptr(ndr, "string", r->string);
18503         ndr->depth++;
18504         if (r->string) {
18505                 ndr_print_string(ndr, "string", r->string);
18506         }
18507         ndr->depth--;
18508         ndr->depth--;
18509 }
18510
18511 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
18512 {
18513         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
18514         return NDR_ERR_SUCCESS;
18515 }
18516
18517 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
18518 {
18519         uint32_t v;
18520         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
18521         *r = v;
18522         return NDR_ERR_SUCCESS;
18523 }
18524
18525 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
18526 {
18527         const char *val = NULL;
18528
18529         switch (r) {
18530                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
18531                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
18532                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
18533                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
18534                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
18535         }
18536         ndr_print_enum(ndr, name, "ENUM", val, r);
18537 }
18538
18539 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
18540 {
18541         if (ndr_flags & NDR_SCALARS) {
18542                 int level = ndr_push_get_switch_value(ndr, r);
18543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18544                 NDR_CHECK(ndr_push_union_align(ndr, 5));
18545                 switch (level) {
18546                         case 1: {
18547                                 uint32_t cntr_integer_0;
18548                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18549                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
18550                                 }
18551                         break; }
18552
18553                         case 2: {
18554                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18555                         break; }
18556
18557                         case 3: {
18558                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18559                         break; }
18560
18561                         case 4: {
18562                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18563                         break; }
18564
18565                         case 5: {
18566                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18567                         break; }
18568
18569                         default:
18570                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18571                 }
18572         }
18573         if (ndr_flags & NDR_BUFFERS) {
18574                 int level = ndr_push_get_switch_value(ndr, r);
18575                 switch (level) {
18576                         case 1:
18577                         break;
18578
18579                         case 2:
18580                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18581                         break;
18582
18583                         case 3:
18584                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18585                         break;
18586
18587                         case 4:
18588                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18589                         break;
18590
18591                         case 5:
18592                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18593                         break;
18594
18595                         default:
18596                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18597                 }
18598         }
18599         return NDR_ERR_SUCCESS;
18600 }
18601
18602 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
18603 {
18604         int level;
18605         uint32_t _level;
18606         level = ndr_pull_get_switch_value(ndr, r);
18607         if (ndr_flags & NDR_SCALARS) {
18608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18609                 if (_level != level) {
18610                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
18611                 }
18612                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
18613                 switch (level) {
18614                         case 1: {
18615                                 uint32_t cntr_integer_0;
18616                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18617                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
18618                                 }
18619                         break; }
18620
18621                         case 2: {
18622                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18623                         break; }
18624
18625                         case 3: {
18626                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18627                         break; }
18628
18629                         case 4: {
18630                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18631                         break; }
18632
18633                         case 5: {
18634                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18635                         break; }
18636
18637                         default:
18638                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18639                 }
18640         }
18641         if (ndr_flags & NDR_BUFFERS) {
18642                 switch (level) {
18643                         case 1:
18644                         break;
18645
18646                         case 2:
18647                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18648                         break;
18649
18650                         case 3:
18651                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18652                         break;
18653
18654                         case 4:
18655                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18656                         break;
18657
18658                         case 5:
18659                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18660                         break;
18661
18662                         default:
18663                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18664                 }
18665         }
18666         return NDR_ERR_SUCCESS;
18667 }
18668
18669 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
18670 {
18671         int level;
18672         uint32_t cntr_integer_0;
18673         level = ndr_print_get_switch_value(ndr, r);
18674         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
18675         switch (level) {
18676                 case 1:
18677                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
18678                         ndr->depth++;
18679                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
18680                                 char *idx_0=NULL;
18681                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
18682                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
18683                                         free(idx_0);
18684                                 }
18685                         }
18686                         ndr->depth--;
18687                 break;
18688
18689                 case 2:
18690                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
18691                 break;
18692
18693                 case 3:
18694                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
18695                 break;
18696
18697                 case 4:
18698                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
18699                 break;
18700
18701                 case 5:
18702                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
18703                 break;
18704
18705                 default:
18706                         ndr_print_bad_level(ndr, name, level);
18707         }
18708 }
18709
18710 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
18711 {
18712         if (ndr_flags & NDR_SCALARS) {
18713                 NDR_CHECK(ndr_push_align(ndr, 5));
18714                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18715                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->field, r->type));
18716                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18717                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
18718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
18719                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
18720                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18721                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18722         }
18723         if (ndr_flags & NDR_BUFFERS) {
18724                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18725         }
18726         return NDR_ERR_SUCCESS;
18727 }
18728
18729 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
18730 {
18731         if (ndr_flags & NDR_SCALARS) {
18732                 NDR_CHECK(ndr_pull_align(ndr, 5));
18733                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18734                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->field, r->type));
18735                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18736                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
18737                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
18738                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
18739                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18740                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18741         }
18742         if (ndr_flags & NDR_BUFFERS) {
18743                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18744         }
18745         return NDR_ERR_SUCCESS;
18746 }
18747
18748 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
18749 {
18750         ndr_print_struct(ndr, name, "spoolss_Notify");
18751         ndr->depth++;
18752         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
18753         ndr_print_set_switch_value(ndr, &r->field, r->type);
18754         ndr_print_spoolss_Field(ndr, "field", &r->field);
18755         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
18756         ndr_print_uint32(ndr, "job_id", r->job_id);
18757         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
18758         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
18759         ndr->depth--;
18760 }
18761
18762 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
18763 {
18764         uint32_t cntr_notifies_0;
18765         if (ndr_flags & NDR_SCALARS) {
18766                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18767                 NDR_CHECK(ndr_push_align(ndr, 5));
18768                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
18769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
18770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18771                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18772                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
18773                 }
18774                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18775         }
18776         if (ndr_flags & NDR_BUFFERS) {
18777                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18778                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
18779                 }
18780         }
18781         return NDR_ERR_SUCCESS;
18782 }
18783
18784 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
18785 {
18786         uint32_t cntr_notifies_0;
18787         TALLOC_CTX *_mem_save_notifies_0;
18788         if (ndr_flags & NDR_SCALARS) {
18789                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
18790                 NDR_CHECK(ndr_pull_align(ndr, 5));
18791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
18793                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18794                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
18795                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
18796                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
18797                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18798                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
18799                 }
18800                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
18801                 if (r->notifies) {
18802                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
18803                 }
18804                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18805         }
18806         if (ndr_flags & NDR_BUFFERS) {
18807                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
18808                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
18809                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18810                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
18811                 }
18812                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
18813         }
18814         return NDR_ERR_SUCCESS;
18815 }
18816
18817 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
18818 {
18819         uint32_t cntr_notifies_0;
18820         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
18821         ndr->depth++;
18822         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
18823         ndr_print_uint32(ndr, "flags", r->flags);
18824         ndr_print_uint32(ndr, "count", r->count);
18825         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
18826         ndr->depth++;
18827         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
18828                 char *idx_0=NULL;
18829                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
18830                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
18831                         free(idx_0);
18832                 }
18833         }
18834         ndr->depth--;
18835         ndr->depth--;
18836 }
18837
18838 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
18839 {
18840         if (ndr_flags & NDR_SCALARS) {
18841                 int level = ndr_push_get_switch_value(ndr, r);
18842                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18843                 NDR_CHECK(ndr_push_union_align(ndr, 5));
18844                 switch (level) {
18845                         case 0: {
18846                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
18847                         break; }
18848
18849                         default:
18850                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18851                 }
18852         }
18853         if (ndr_flags & NDR_BUFFERS) {
18854                 int level = ndr_push_get_switch_value(ndr, r);
18855                 switch (level) {
18856                         case 0:
18857                                 if (r->info0) {
18858                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
18859                                 }
18860                         break;
18861
18862                         default:
18863                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18864                 }
18865         }
18866         return NDR_ERR_SUCCESS;
18867 }
18868
18869 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
18870 {
18871         int level;
18872         uint32_t _level;
18873         TALLOC_CTX *_mem_save_info0_0;
18874         level = ndr_pull_get_switch_value(ndr, r);
18875         if (ndr_flags & NDR_SCALARS) {
18876                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18877                 if (_level != level) {
18878                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
18879                 }
18880                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
18881                 switch (level) {
18882                         case 0: {
18883                                 uint32_t _ptr_info0;
18884                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
18885                                 if (_ptr_info0) {
18886                                         NDR_PULL_ALLOC(ndr, r->info0);
18887                                 } else {
18888                                         r->info0 = NULL;
18889                                 }
18890                         break; }
18891
18892                         default:
18893                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18894                 }
18895         }
18896         if (ndr_flags & NDR_BUFFERS) {
18897                 switch (level) {
18898                         case 0:
18899                                 if (r->info0) {
18900                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
18901                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
18902                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
18903                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
18904                                 }
18905                         break;
18906
18907                         default:
18908                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18909                 }
18910         }
18911         return NDR_ERR_SUCCESS;
18912 }
18913
18914 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
18915 {
18916         int level;
18917         level = ndr_print_get_switch_value(ndr, r);
18918         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
18919         switch (level) {
18920                 case 0:
18921                         ndr_print_ptr(ndr, "info0", r->info0);
18922                         ndr->depth++;
18923                         if (r->info0) {
18924                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
18925                         }
18926                         ndr->depth--;
18927                 break;
18928
18929                 default:
18930                         ndr_print_bad_level(ndr, name, level);
18931         }
18932 }
18933
18934 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18935 {
18936         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18937         return NDR_ERR_SUCCESS;
18938 }
18939
18940 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18941 {
18942         uint32_t v;
18943         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18944         *r = v;
18945         return NDR_ERR_SUCCESS;
18946 }
18947
18948 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18949 {
18950         ndr_print_uint32(ndr, name, r);
18951         ndr->depth++;
18952         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
18953         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
18954         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
18955         ndr->depth--;
18956 }
18957
18958 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
18959 {
18960         if (ndr_flags & NDR_SCALARS) {
18961                 NDR_CHECK(ndr_push_align(ndr, 5));
18962                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18963                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
18964                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
18965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
18966                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
18967                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
18968                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
18969                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18970         }
18971         if (ndr_flags & NDR_BUFFERS) {
18972                 if (r->client) {
18973                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18974                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18975                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18976                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18977                 }
18978                 if (r->user) {
18979                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18980                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18981                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18982                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18983                 }
18984         }
18985         return NDR_ERR_SUCCESS;
18986 }
18987
18988 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
18989 {
18990         uint32_t _ptr_client;
18991         TALLOC_CTX *_mem_save_client_0;
18992         uint32_t _ptr_user;
18993         TALLOC_CTX *_mem_save_user_0;
18994         if (ndr_flags & NDR_SCALARS) {
18995                 NDR_CHECK(ndr_pull_align(ndr, 5));
18996                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18997                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
18998                 if (_ptr_client) {
18999                         NDR_PULL_ALLOC(ndr, r->client);
19000                 } else {
19001                         r->client = NULL;
19002                 }
19003                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19004                 if (_ptr_user) {
19005                         NDR_PULL_ALLOC(ndr, r->user);
19006                 } else {
19007                         r->user = NULL;
19008                 }
19009                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19010                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19011                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19012                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19013                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19014         }
19015         if (ndr_flags & NDR_BUFFERS) {
19016                 if (r->client) {
19017                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19018                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19019                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19020                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19021                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19022                                 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));
19023                         }
19024                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19025                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19026                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19027                 }
19028                 if (r->user) {
19029                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19030                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19031                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19032                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19033                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19034                                 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));
19035                         }
19036                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19037                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19038                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19039                 }
19040         }
19041         return NDR_ERR_SUCCESS;
19042 }
19043
19044 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
19045 {
19046         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
19047         ndr->depth++;
19048         ndr_print_uint32(ndr, "size", r->size);
19049         ndr_print_ptr(ndr, "client", r->client);
19050         ndr->depth++;
19051         if (r->client) {
19052                 ndr_print_string(ndr, "client", r->client);
19053         }
19054         ndr->depth--;
19055         ndr_print_ptr(ndr, "user", r->user);
19056         ndr->depth++;
19057         if (r->user) {
19058                 ndr_print_string(ndr, "user", r->user);
19059         }
19060         ndr->depth--;
19061         ndr_print_uint32(ndr, "build", r->build);
19062         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19063         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19064         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19065         ndr->depth--;
19066 }
19067
19068 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
19069 {
19070         if (ndr_flags & NDR_SCALARS) {
19071                 NDR_CHECK(ndr_push_align(ndr, 4));
19072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
19073                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19074         }
19075         if (ndr_flags & NDR_BUFFERS) {
19076         }
19077         return NDR_ERR_SUCCESS;
19078 }
19079
19080 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
19081 {
19082         if (ndr_flags & NDR_SCALARS) {
19083                 NDR_CHECK(ndr_pull_align(ndr, 4));
19084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
19085                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19086         }
19087         if (ndr_flags & NDR_BUFFERS) {
19088         }
19089         return NDR_ERR_SUCCESS;
19090 }
19091
19092 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
19093 {
19094         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
19095         ndr->depth++;
19096         ndr_print_uint32(ndr, "not_used", r->not_used);
19097         ndr->depth--;
19098 }
19099
19100 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
19101 {
19102         if (ndr_flags & NDR_SCALARS) {
19103                 NDR_CHECK(ndr_push_align(ndr, 5));
19104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
19106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
19107                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
19108                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
19109                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
19110                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
19111                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
19112                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
19113                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
19114                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19115         }
19116         if (ndr_flags & NDR_BUFFERS) {
19117                 if (r->client) {
19118                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19119                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19120                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19121                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19122                 }
19123                 if (r->user) {
19124                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19125                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19126                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19127                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19128                 }
19129         }
19130         return NDR_ERR_SUCCESS;
19131 }
19132
19133 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
19134 {
19135         uint32_t _ptr_client;
19136         TALLOC_CTX *_mem_save_client_0;
19137         uint32_t _ptr_user;
19138         TALLOC_CTX *_mem_save_user_0;
19139         if (ndr_flags & NDR_SCALARS) {
19140                 NDR_CHECK(ndr_pull_align(ndr, 5));
19141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
19143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
19144                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19145                 if (_ptr_client) {
19146                         NDR_PULL_ALLOC(ndr, r->client);
19147                 } else {
19148                         r->client = NULL;
19149                 }
19150                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19151                 if (_ptr_user) {
19152                         NDR_PULL_ALLOC(ndr, r->user);
19153                 } else {
19154                         r->user = NULL;
19155                 }
19156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19157                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19158                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19159                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19160                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
19161                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19162         }
19163         if (ndr_flags & NDR_BUFFERS) {
19164                 if (r->client) {
19165                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19166                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19167                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19168                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19169                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19170                                 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));
19171                         }
19172                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19173                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19174                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19175                 }
19176                 if (r->user) {
19177                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19178                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19179                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19180                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19181                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19182                                 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));
19183                         }
19184                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19185                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19186                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19187                 }
19188         }
19189         return NDR_ERR_SUCCESS;
19190 }
19191
19192 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
19193 {
19194         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
19195         ndr->depth++;
19196         ndr_print_uint32(ndr, "size", r->size);
19197         ndr_print_uint32(ndr, "flags", r->flags);
19198         ndr_print_uint32(ndr, "size2", r->size2);
19199         ndr_print_ptr(ndr, "client", r->client);
19200         ndr->depth++;
19201         if (r->client) {
19202                 ndr_print_string(ndr, "client", r->client);
19203         }
19204         ndr->depth--;
19205         ndr_print_ptr(ndr, "user", r->user);
19206         ndr->depth++;
19207         if (r->user) {
19208                 ndr_print_string(ndr, "user", r->user);
19209         }
19210         ndr->depth--;
19211         ndr_print_uint32(ndr, "build", r->build);
19212         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19213         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19214         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19215         ndr_print_udlong(ndr, "reserved", r->reserved);
19216         ndr->depth--;
19217 }
19218
19219 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
19220 {
19221         if (ndr_flags & NDR_SCALARS) {
19222                 int level = ndr_push_get_switch_value(ndr, r);
19223                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19224                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19225                 switch (level) {
19226                         case 1: {
19227                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
19228                         break; }
19229
19230                         case 2: {
19231                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
19232                         break; }
19233
19234                         case 3: {
19235                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
19236                         break; }
19237
19238                         default:
19239                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19240                 }
19241         }
19242         if (ndr_flags & NDR_BUFFERS) {
19243                 int level = ndr_push_get_switch_value(ndr, r);
19244                 switch (level) {
19245                         case 1:
19246                                 if (r->level1) {
19247                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
19248                                 }
19249                         break;
19250
19251                         case 2:
19252                                 if (r->level2) {
19253                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
19254                                 }
19255                         break;
19256
19257                         case 3:
19258                                 if (r->level3) {
19259                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
19260                                 }
19261                         break;
19262
19263                         default:
19264                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19265                 }
19266         }
19267         return NDR_ERR_SUCCESS;
19268 }
19269
19270 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
19271 {
19272         int level;
19273         uint32_t _level;
19274         TALLOC_CTX *_mem_save_level1_0;
19275         TALLOC_CTX *_mem_save_level2_0;
19276         TALLOC_CTX *_mem_save_level3_0;
19277         level = ndr_pull_get_switch_value(ndr, r);
19278         if (ndr_flags & NDR_SCALARS) {
19279                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19280                 if (_level != level) {
19281                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19282                 }
19283                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19284                 switch (level) {
19285                         case 1: {
19286                                 uint32_t _ptr_level1;
19287                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
19288                                 if (_ptr_level1) {
19289                                         NDR_PULL_ALLOC(ndr, r->level1);
19290                                 } else {
19291                                         r->level1 = NULL;
19292                                 }
19293                         break; }
19294
19295                         case 2: {
19296                                 uint32_t _ptr_level2;
19297                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
19298                                 if (_ptr_level2) {
19299                                         NDR_PULL_ALLOC(ndr, r->level2);
19300                                 } else {
19301                                         r->level2 = NULL;
19302                                 }
19303                         break; }
19304
19305                         case 3: {
19306                                 uint32_t _ptr_level3;
19307                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
19308                                 if (_ptr_level3) {
19309                                         NDR_PULL_ALLOC(ndr, r->level3);
19310                                 } else {
19311                                         r->level3 = NULL;
19312                                 }
19313                         break; }
19314
19315                         default:
19316                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19317                 }
19318         }
19319         if (ndr_flags & NDR_BUFFERS) {
19320                 switch (level) {
19321                         case 1:
19322                                 if (r->level1) {
19323                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
19324                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
19325                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
19326                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
19327                                 }
19328                         break;
19329
19330                         case 2:
19331                                 if (r->level2) {
19332                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
19333                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
19334                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
19335                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
19336                                 }
19337                         break;
19338
19339                         case 3:
19340                                 if (r->level3) {
19341                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
19342                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
19343                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
19344                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
19345                                 }
19346                         break;
19347
19348                         default:
19349                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19350                 }
19351         }
19352         return NDR_ERR_SUCCESS;
19353 }
19354
19355 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
19356 {
19357         int level;
19358         level = ndr_print_get_switch_value(ndr, r);
19359         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
19360         switch (level) {
19361                 case 1:
19362                         ndr_print_ptr(ndr, "level1", r->level1);
19363                         ndr->depth++;
19364                         if (r->level1) {
19365                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
19366                         }
19367                         ndr->depth--;
19368                 break;
19369
19370                 case 2:
19371                         ndr_print_ptr(ndr, "level2", r->level2);
19372                         ndr->depth++;
19373                         if (r->level2) {
19374                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
19375                         }
19376                         ndr->depth--;
19377                 break;
19378
19379                 case 3:
19380                         ndr_print_ptr(ndr, "level3", r->level3);
19381                         ndr->depth++;
19382                         if (r->level3) {
19383                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
19384                         }
19385                         ndr->depth--;
19386                 break;
19387
19388                 default:
19389                         ndr_print_bad_level(ndr, name, level);
19390         }
19391 }
19392
19393 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
19394 {
19395         if (ndr_flags & NDR_SCALARS) {
19396                 NDR_CHECK(ndr_push_align(ndr, 5));
19397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
19398                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
19399                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
19400                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19401         }
19402         if (ndr_flags & NDR_BUFFERS) {
19403                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
19404         }
19405         return NDR_ERR_SUCCESS;
19406 }
19407
19408 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
19409 {
19410         if (ndr_flags & NDR_SCALARS) {
19411                 NDR_CHECK(ndr_pull_align(ndr, 5));
19412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
19413                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
19414                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
19415                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19416         }
19417         if (ndr_flags & NDR_BUFFERS) {
19418                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
19419         }
19420         return NDR_ERR_SUCCESS;
19421 }
19422
19423 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
19424 {
19425         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
19426         ndr->depth++;
19427         ndr_print_uint32(ndr, "level", r->level);
19428         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
19429         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
19430         ndr->depth--;
19431 }
19432
19433 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19434 {
19435         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19436         return NDR_ERR_SUCCESS;
19437 }
19438
19439 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19440 {
19441         uint32_t v;
19442         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19443         *r = v;
19444         return NDR_ERR_SUCCESS;
19445 }
19446
19447 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
19448 {
19449         ndr_print_uint32(ndr, name, r);
19450         ndr->depth++;
19451         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
19452         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
19453         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
19454         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
19455         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
19456         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
19457         ndr->depth--;
19458 }
19459
19460 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
19461 {
19462         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
19463         if (ndr_flags & NDR_SCALARS) {
19464                 NDR_CHECK(ndr_push_align(ndr, 5));
19465                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
19466                 {
19467                         uint32_t _flags_save_string = ndr->flags;
19468                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19469                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
19470                         ndr->flags = _flags_save_string;
19471                 }
19472                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
19473                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
19474                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
19475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags)));
19476                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19477         }
19478         if (ndr_flags & NDR_BUFFERS) {
19479                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
19480                 {
19481                         uint32_t _flags_save_string = ndr->flags;
19482                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19483                         if (r->value_name) {
19484                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value_name));
19485                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
19486                         }
19487                         ndr->flags = _flags_save_string;
19488                 }
19489                 if (r->data) {
19490                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data));
19491                         {
19492                                 struct ndr_push *_ndr_data;
19493                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
19494                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_data, r->data, r->type));
19495                                 NDR_CHECK(ndr_push_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
19496                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data_length));
19497                         }
19498                 }
19499         }
19500         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
19501         return NDR_ERR_SUCCESS;
19502 }
19503
19504 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
19505 {
19506         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
19507         uint32_t _ptr_value_name;
19508         TALLOC_CTX *_mem_save_value_name_0;
19509         uint32_t _ptr_data;
19510         TALLOC_CTX *_mem_save_data_0;
19511         if (ndr_flags & NDR_SCALARS) {
19512                 NDR_CHECK(ndr_pull_align(ndr, 5));
19513                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
19514                 {
19515                         uint32_t _flags_save_string = ndr->flags;
19516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19517                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
19518                         if (_ptr_value_name) {
19519                                 NDR_PULL_ALLOC(ndr, r->value_name);
19520                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
19521                         } else {
19522                                 r->value_name = NULL;
19523                         }
19524                         ndr->flags = _flags_save_string;
19525                 }
19526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
19527                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
19528                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
19529                 if (_ptr_data) {
19530                         NDR_PULL_ALLOC(ndr, r->data);
19531                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
19532                 } else {
19533                         r->data = NULL;
19534                 }
19535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
19536                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19537         }
19538         if (ndr_flags & NDR_BUFFERS) {
19539                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
19540                 {
19541                         uint32_t _flags_save_string = ndr->flags;
19542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19543                         if (r->value_name) {
19544                                 uint32_t _relative_save_offset;
19545                                 _relative_save_offset = ndr->offset;
19546                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
19547                                 _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
19548                                 NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
19549                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
19550                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
19551                                 if (ndr->offset > ndr->relative_highest_offset) {
19552                                         ndr->relative_highest_offset = ndr->offset;
19553                                 }
19554                                 ndr->offset = _relative_save_offset;
19555                         }
19556                         ndr->flags = _flags_save_string;
19557                 }
19558                 if (r->data) {
19559                         uint32_t _relative_save_offset;
19560                         _relative_save_offset = ndr->offset;
19561                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
19562                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
19563                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
19564                         {
19565                                 struct ndr_pull *_ndr_data;
19566                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
19567                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, r->data, r->type));
19568                                 NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
19569                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
19570                         }
19571                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
19572                         if (ndr->offset > ndr->relative_highest_offset) {
19573                                 ndr->relative_highest_offset = ndr->offset;
19574                         }
19575                         ndr->offset = _relative_save_offset;
19576                 }
19577         }
19578         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
19579         return NDR_ERR_SUCCESS;
19580 }
19581
19582 _PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
19583 {
19584         ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
19585         ndr->depth++;
19586         ndr_print_ptr(ndr, "value_name", r->value_name);
19587         ndr->depth++;
19588         if (r->value_name) {
19589                 ndr_print_string(ndr, "value_name", r->value_name);
19590         }
19591         ndr->depth--;
19592         ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
19593         ndr_print_winreg_Type(ndr, "type", r->type);
19594         ndr_print_ptr(ndr, "data", r->data);
19595         ndr->depth++;
19596         if (r->data) {
19597                 ndr_print_set_switch_value(ndr, r->data, r->type);
19598                 ndr_print_spoolss_PrinterData(ndr, "data", r->data);
19599         }
19600         ndr->depth--;
19601         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);
19602         ndr->depth--;
19603 }
19604
19605 _PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
19606 {
19607         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
19608 }
19609
19610 static enum ndr_err_code ndr_push_spoolss_KeyNames(struct ndr_push *ndr, int ndr_flags, const union spoolss_KeyNames *r)
19611 {
19612         if (ndr_flags & NDR_SCALARS) {
19613                 int level = ndr_push_get_switch_value(ndr, r);
19614                 NDR_CHECK(ndr_push_union_align(ndr, 4));
19615                 switch (level) {
19616                         case 0: {
19617                         break; }
19618
19619                         case 1: {
19620                         break; }
19621
19622                         default: {
19623                                 {
19624                                         uint32_t _flags_save_string_array = ndr->flags;
19625                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19626                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
19627                                         ndr->flags = _flags_save_string_array;
19628                                 }
19629                         break; }
19630
19631                 }
19632         }
19633         if (ndr_flags & NDR_BUFFERS) {
19634                 int level = ndr_push_get_switch_value(ndr, r);
19635                 switch (level) {
19636                         case 0:
19637                         break;
19638
19639                         case 1:
19640                         break;
19641
19642                         default:
19643                         break;
19644
19645                 }
19646         }
19647         return NDR_ERR_SUCCESS;
19648 }
19649
19650 static enum ndr_err_code ndr_pull_spoolss_KeyNames(struct ndr_pull *ndr, int ndr_flags, union spoolss_KeyNames *r)
19651 {
19652         int level;
19653         level = ndr_pull_get_switch_value(ndr, r);
19654         if (ndr_flags & NDR_SCALARS) {
19655                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
19656                 switch (level) {
19657                         case 0: {
19658                         break; }
19659
19660                         case 1: {
19661                         break; }
19662
19663                         default: {
19664                                 {
19665                                         uint32_t _flags_save_string_array = ndr->flags;
19666                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19667                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
19668                                         ndr->flags = _flags_save_string_array;
19669                                 }
19670                         break; }
19671
19672                 }
19673         }
19674         if (ndr_flags & NDR_BUFFERS) {
19675                 switch (level) {
19676                         case 0:
19677                         break;
19678
19679                         case 1:
19680                         break;
19681
19682                         default:
19683                         break;
19684
19685                 }
19686         }
19687         return NDR_ERR_SUCCESS;
19688 }
19689
19690 _PUBLIC_ void ndr_print_spoolss_KeyNames(struct ndr_print *ndr, const char *name, const union spoolss_KeyNames *r)
19691 {
19692         int level;
19693         level = ndr_print_get_switch_value(ndr, r);
19694         ndr_print_union(ndr, name, level, "spoolss_KeyNames");
19695         switch (level) {
19696                 case 0:
19697                 break;
19698
19699                 case 1:
19700                 break;
19701
19702                 default:
19703                         ndr_print_string_array(ndr, "string_array", r->string_array);
19704                 break;
19705
19706         }
19707 }
19708
19709 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19710 {
19711         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19712         return NDR_ERR_SUCCESS;
19713 }
19714
19715 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19716 {
19717         uint32_t v;
19718         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19719         *r = v;
19720         return NDR_ERR_SUCCESS;
19721 }
19722
19723 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19724 {
19725         ndr_print_uint32(ndr, name, r);
19726         ndr->depth++;
19727         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
19728         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
19729         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
19730         ndr->depth--;
19731 }
19732
19733 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
19734 {
19735         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
19736         return NDR_ERR_SUCCESS;
19737 }
19738
19739 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
19740 {
19741         uint32_t v;
19742         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
19743         *r = v;
19744         return NDR_ERR_SUCCESS;
19745 }
19746
19747 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
19748 {
19749         const char *val = NULL;
19750
19751         switch (r) {
19752                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
19753                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
19754         }
19755         ndr_print_enum(ndr, name, "ENUM", val, r);
19756 }
19757
19758 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
19759 {
19760         if (ndr_flags & NDR_SCALARS) {
19761                 NDR_CHECK(ndr_push_align(ndr, 4));
19762                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
19763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
19764                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
19765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
19766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
19767                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
19768                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
19770                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
19771                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
19772                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
19773                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
19775                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
19776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
19777                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19778         }
19779         if (ndr_flags & NDR_BUFFERS) {
19780         }
19781         return NDR_ERR_SUCCESS;
19782 }
19783
19784 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
19785 {
19786         if (ndr_flags & NDR_SCALARS) {
19787                 NDR_CHECK(ndr_pull_align(ndr, 4));
19788                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
19789                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19790                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
19791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
19793                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
19794                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19795                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
19796                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
19797                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
19798                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
19799                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19800                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
19801                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
19802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
19803                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19804         }
19805         if (ndr_flags & NDR_BUFFERS) {
19806         }
19807         return NDR_ERR_SUCCESS;
19808 }
19809
19810 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
19811 {
19812         ndr_print_struct(ndr, name, "spoolss_PortData1");
19813         ndr->depth++;
19814         ndr_print_string(ndr, "portname", r->portname);
19815         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
19816         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
19817         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
19818         ndr_print_uint32(ndr, "reserved", r->reserved);
19819         ndr_print_string(ndr, "hostaddress", r->hostaddress);
19820         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
19821         ndr_print_uint32(ndr, "dblspool", r->dblspool);
19822         ndr_print_string(ndr, "queue", r->queue);
19823         ndr_print_string(ndr, "ip_address", r->ip_address);
19824         ndr_print_string(ndr, "hardware_address", r->hardware_address);
19825         ndr_print_string(ndr, "device_type", r->device_type);
19826         ndr_print_uint32(ndr, "port_number", r->port_number);
19827         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
19828         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
19829         ndr->depth--;
19830 }
19831
19832 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
19833 {
19834         if (ndr_flags & NDR_SCALARS) {
19835                 NDR_CHECK(ndr_push_align(ndr, 4));
19836                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
19837                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
19838                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
19839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
19840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
19841                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
19842                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19843                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
19844                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
19845                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19846                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
19847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
19848                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
19849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
19850                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19851         }
19852         if (ndr_flags & NDR_BUFFERS) {
19853         }
19854         return NDR_ERR_SUCCESS;
19855 }
19856
19857 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
19858 {
19859         if (ndr_flags & NDR_SCALARS) {
19860                 NDR_CHECK(ndr_pull_align(ndr, 4));
19861                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
19862                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19863                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
19864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19865                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
19866                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
19867                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19868                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
19869                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
19870                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
19872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
19873                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
19874                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
19875                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19876         }
19877         if (ndr_flags & NDR_BUFFERS) {
19878         }
19879         return NDR_ERR_SUCCESS;
19880 }
19881
19882 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
19883 {
19884         ndr_print_struct(ndr, name, "spoolss_PortData2");
19885         ndr->depth++;
19886         ndr_print_string(ndr, "portname", r->portname);
19887         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
19888         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
19889         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
19890         ndr_print_uint32(ndr, "reserved", r->reserved);
19891         ndr_print_string(ndr, "hostaddress", r->hostaddress);
19892         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
19893         ndr_print_uint32(ndr, "dblspool", r->dblspool);
19894         ndr_print_string(ndr, "queue", r->queue);
19895         ndr_print_string(ndr, "device_type", r->device_type);
19896         ndr_print_uint32(ndr, "port_number", r->port_number);
19897         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
19898         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
19899         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
19900         ndr->depth--;
19901 }
19902
19903 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
19904 {
19905         if (ndr_flags & NDR_SCALARS) {
19906                 NDR_CHECK(ndr_push_align(ndr, 4));
19907                 {
19908                         uint32_t _flags_save_string = ndr->flags;
19909                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19910                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
19911                         ndr->flags = _flags_save_string;
19912                 }
19913                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19914         }
19915         if (ndr_flags & NDR_BUFFERS) {
19916         }
19917         return NDR_ERR_SUCCESS;
19918 }
19919
19920 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
19921 {
19922         if (ndr_flags & NDR_SCALARS) {
19923                 NDR_CHECK(ndr_pull_align(ndr, 4));
19924                 {
19925                         uint32_t _flags_save_string = ndr->flags;
19926                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19927                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
19928                         ndr->flags = _flags_save_string;
19929                 }
19930                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19931         }
19932         if (ndr_flags & NDR_BUFFERS) {
19933         }
19934         return NDR_ERR_SUCCESS;
19935 }
19936
19937 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
19938 {
19939         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
19940         ndr->depth++;
19941         ndr_print_string(ndr, "dll_name", r->dll_name);
19942         ndr->depth--;
19943 }
19944
19945 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19946 {
19947         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19948         return NDR_ERR_SUCCESS;
19949 }
19950
19951 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19952 {
19953         uint32_t v;
19954         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19955         *r = v;
19956         return NDR_ERR_SUCCESS;
19957 }
19958
19959 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19960 {
19961         ndr_print_uint32(ndr, name, r);
19962         ndr->depth++;
19963         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
19964         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
19965         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
19966         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
19967         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
19968         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
19969         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
19970         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
19971         ndr->depth--;
19972 }
19973
19974 static enum ndr_err_code ndr_push_spoolss_CorePrinterDriver(struct ndr_push *ndr, int ndr_flags, const struct spoolss_CorePrinterDriver *r)
19975 {
19976         if (ndr_flags & NDR_SCALARS) {
19977                 NDR_CHECK(ndr_push_align(ndr, 8));
19978                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
19979                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
19980                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
19981                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 520, sizeof(uint8_t), CH_UTF8));
19982                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
19983         }
19984         if (ndr_flags & NDR_BUFFERS) {
19985         }
19986         return NDR_ERR_SUCCESS;
19987 }
19988
19989 static enum ndr_err_code ndr_pull_spoolss_CorePrinterDriver(struct ndr_pull *ndr, int ndr_flags, struct spoolss_CorePrinterDriver *r)
19990 {
19991         if (ndr_flags & NDR_SCALARS) {
19992                 NDR_CHECK(ndr_pull_align(ndr, 8));
19993                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
19994                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
19995                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
19996                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 520, sizeof(uint8_t), CH_UTF8));
19997                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
19998         }
19999         if (ndr_flags & NDR_BUFFERS) {
20000         }
20001         return NDR_ERR_SUCCESS;
20002 }
20003
20004 _PUBLIC_ void ndr_print_spoolss_CorePrinterDriver(struct ndr_print *ndr, const char *name, const struct spoolss_CorePrinterDriver *r)
20005 {
20006         ndr_print_struct(ndr, name, "spoolss_CorePrinterDriver");
20007         ndr->depth++;
20008         ndr_print_GUID(ndr, "core_driver_guid", &r->core_driver_guid);
20009         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
20010         ndr_print_hyper(ndr, "driver_version", r->driver_version);
20011         ndr_print_string(ndr, "formname", r->formname);
20012         ndr->depth--;
20013 }
20014
20015 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
20016 {
20017         if (flags & NDR_IN) {
20018                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
20019                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20020                 if (r->in.server) {
20021                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20022                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20023                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20024                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20025                 }
20026                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20027                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20028                 if (r->in.buffer) {
20029                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20030                 }
20031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20032         }
20033         if (flags & NDR_OUT) {
20034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20035                 if (r->out.info) {
20036                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20037                 }
20038                 if (r->out.needed == NULL) {
20039                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20040                 }
20041                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20042                 if (r->out.count == NULL) {
20043                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20044                 }
20045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20046                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20047         }
20048         return NDR_ERR_SUCCESS;
20049 }
20050
20051 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
20052 {
20053         uint32_t _ptr_server;
20054         uint32_t _ptr_buffer;
20055         uint32_t _ptr_info;
20056         TALLOC_CTX *_mem_save_server_0;
20057         TALLOC_CTX *_mem_save_buffer_0;
20058         TALLOC_CTX *_mem_save_info_0;
20059         TALLOC_CTX *_mem_save_needed_0;
20060         TALLOC_CTX *_mem_save_count_0;
20061         if (flags & NDR_IN) {
20062                 ZERO_STRUCT(r->out);
20063
20064                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
20065                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20066                 if (_ptr_server) {
20067                         NDR_PULL_ALLOC(ndr, r->in.server);
20068                 } else {
20069                         r->in.server = NULL;
20070                 }
20071                 if (r->in.server) {
20072                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20073                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20074                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20075                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20076                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20077                                 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));
20078                         }
20079                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20080                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20081                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20082                 }
20083                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20084                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20085                 if (_ptr_buffer) {
20086                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20087                 } else {
20088                         r->in.buffer = NULL;
20089                 }
20090                 if (r->in.buffer) {
20091                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20092                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20093                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20094                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20095                 }
20096                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20097                 NDR_PULL_ALLOC(ndr, r->out.needed);
20098                 ZERO_STRUCTP(r->out.needed);
20099                 NDR_PULL_ALLOC(ndr, r->out.count);
20100                 ZERO_STRUCTP(r->out.count);
20101         }
20102         if (flags & NDR_OUT) {
20103                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20104                 if (_ptr_info) {
20105                         NDR_PULL_ALLOC(ndr, r->out.info);
20106                 } else {
20107                         r->out.info = NULL;
20108                 }
20109                 if (r->out.info) {
20110                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20111                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20112                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20113                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20114                 }
20115                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20116                         NDR_PULL_ALLOC(ndr, r->out.needed);
20117                 }
20118                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20119                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20120                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20121                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20122                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20123                         NDR_PULL_ALLOC(ndr, r->out.count);
20124                 }
20125                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20126                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20127                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20128                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20129                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20130         }
20131         return NDR_ERR_SUCCESS;
20132 }
20133
20134 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
20135 {
20136         uint32_t cntr_info_0;
20137         if (flags & NDR_IN) {
20138                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20139                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20140         }
20141         if (flags & NDR_OUT) {
20142                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20143                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20144                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20145                 }
20146                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20147                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20148                 }
20149         }
20150         return NDR_ERR_SUCCESS;
20151 }
20152
20153 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
20154 {
20155         uint32_t cntr_info_0;
20156         TALLOC_CTX *_mem_save_info_0;
20157         if (flags & NDR_IN) {
20158                 ZERO_STRUCT(r->out);
20159
20160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20162         }
20163         if (flags & NDR_OUT) {
20164                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20165                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20166                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20167                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20168                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20169                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20170                 }
20171                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20172                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20173                 }
20174                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20175         }
20176         return NDR_ERR_SUCCESS;
20177 }
20178
20179 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
20180 {
20181         uint32_t cntr_info_2;
20182         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
20183         ndr->depth++;
20184         if (flags & NDR_SET_VALUES) {
20185                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20186         }
20187         if (flags & NDR_IN) {
20188                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
20189                 ndr->depth++;
20190                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
20191                 ndr_print_ptr(ndr, "server", r->in.server);
20192                 ndr->depth++;
20193                 if (r->in.server) {
20194                         ndr_print_string(ndr, "server", r->in.server);
20195                 }
20196                 ndr->depth--;
20197                 ndr_print_uint32(ndr, "level", r->in.level);
20198                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20199                 ndr->depth++;
20200                 if (r->in.buffer) {
20201                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20202                 }
20203                 ndr->depth--;
20204                 ndr_print_uint32(ndr, "offered", r->in.offered);
20205                 ndr->depth--;
20206         }
20207         if (flags & NDR_OUT) {
20208                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
20209                 ndr->depth++;
20210                 ndr_print_ptr(ndr, "count", r->out.count);
20211                 ndr->depth++;
20212                 ndr_print_uint32(ndr, "count", *r->out.count);
20213                 ndr->depth--;
20214                 ndr_print_ptr(ndr, "info", r->out.info);
20215                 ndr->depth++;
20216                 ndr_print_ptr(ndr, "info", *r->out.info);
20217                 ndr->depth++;
20218                 if (*r->out.info) {
20219                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20220                         ndr->depth++;
20221                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20222                                 char *idx_2=NULL;
20223                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20224                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20225                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20226                                         free(idx_2);
20227                                 }
20228                         }
20229                         ndr->depth--;
20230                 }
20231                 ndr->depth--;
20232                 ndr->depth--;
20233                 ndr_print_ptr(ndr, "needed", r->out.needed);
20234                 ndr->depth++;
20235                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20236                 ndr->depth--;
20237                 ndr_print_WERROR(ndr, "result", r->out.result);
20238                 ndr->depth--;
20239         }
20240         ndr->depth--;
20241 }
20242
20243 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
20244 {
20245         if (flags & NDR_IN) {
20246                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
20247                 if (r->in.printername) {
20248                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20249                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20250                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20251                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20252                 }
20253                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
20254                 if (r->in.datatype) {
20255                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20256                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20257                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20258                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20259                 }
20260                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20261                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
20262         }
20263         if (flags & NDR_OUT) {
20264                 if (r->out.handle == NULL) {
20265                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20266                 }
20267                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20268                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20269         }
20270         return NDR_ERR_SUCCESS;
20271 }
20272
20273 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
20274 {
20275         uint32_t _ptr_printername;
20276         uint32_t _ptr_datatype;
20277         TALLOC_CTX *_mem_save_printername_0;
20278         TALLOC_CTX *_mem_save_datatype_0;
20279         TALLOC_CTX *_mem_save_handle_0;
20280         if (flags & NDR_IN) {
20281                 ZERO_STRUCT(r->out);
20282
20283                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
20284                 if (_ptr_printername) {
20285                         NDR_PULL_ALLOC(ndr, r->in.printername);
20286                 } else {
20287                         r->in.printername = NULL;
20288                 }
20289                 if (r->in.printername) {
20290                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20291                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
20292                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
20293                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
20294                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
20295                                 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));
20296                         }
20297                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
20298                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
20299                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
20300                 }
20301                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
20302                 if (_ptr_datatype) {
20303                         NDR_PULL_ALLOC(ndr, r->in.datatype);
20304                 } else {
20305                         r->in.datatype = NULL;
20306                 }
20307                 if (r->in.datatype) {
20308                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
20309                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
20310                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
20311                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
20312                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
20313                                 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));
20314                         }
20315                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
20316                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
20317                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
20318                 }
20319                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20320                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
20321                 NDR_PULL_ALLOC(ndr, r->out.handle);
20322                 ZERO_STRUCTP(r->out.handle);
20323         }
20324         if (flags & NDR_OUT) {
20325                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20326                         NDR_PULL_ALLOC(ndr, r->out.handle);
20327                 }
20328                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20329                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20330                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20331                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20332                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20333         }
20334         return NDR_ERR_SUCCESS;
20335 }
20336
20337 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
20338 {
20339         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
20340         ndr->depth++;
20341         if (flags & NDR_SET_VALUES) {
20342                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20343         }
20344         if (flags & NDR_IN) {
20345                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
20346                 ndr->depth++;
20347                 ndr_print_ptr(ndr, "printername", r->in.printername);
20348                 ndr->depth++;
20349                 if (r->in.printername) {
20350                         ndr_print_string(ndr, "printername", r->in.printername);
20351                 }
20352                 ndr->depth--;
20353                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
20354                 ndr->depth++;
20355                 if (r->in.datatype) {
20356                         ndr_print_string(ndr, "datatype", r->in.datatype);
20357                 }
20358                 ndr->depth--;
20359                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
20360                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
20361                 ndr->depth--;
20362         }
20363         if (flags & NDR_OUT) {
20364                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
20365                 ndr->depth++;
20366                 ndr_print_ptr(ndr, "handle", r->out.handle);
20367                 ndr->depth++;
20368                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20369                 ndr->depth--;
20370                 ndr_print_WERROR(ndr, "result", r->out.result);
20371                 ndr->depth--;
20372         }
20373         ndr->depth--;
20374 }
20375
20376 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
20377 {
20378         if (flags & NDR_IN) {
20379                 if (r->in.handle == NULL) {
20380                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20381                 }
20382                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
20384                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
20385                 if (r->in.ctr) {
20386                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
20387                 }
20388                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
20389         }
20390         if (flags & NDR_OUT) {
20391                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20392         }
20393         return NDR_ERR_SUCCESS;
20394 }
20395
20396 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
20397 {
20398         uint32_t _ptr_ctr;
20399         TALLOC_CTX *_mem_save_handle_0;
20400         TALLOC_CTX *_mem_save_ctr_0;
20401         if (flags & NDR_IN) {
20402                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20403                         NDR_PULL_ALLOC(ndr, r->in.handle);
20404                 }
20405                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20406                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20407                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20408                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20409                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
20410                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
20411                 if (_ptr_ctr) {
20412                         NDR_PULL_ALLOC(ndr, r->in.ctr);
20413                 } else {
20414                         r->in.ctr = NULL;
20415                 }
20416                 if (r->in.ctr) {
20417                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20418                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
20419                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
20420                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
20421                 }
20422                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
20423         }
20424         if (flags & NDR_OUT) {
20425                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20426         }
20427         return NDR_ERR_SUCCESS;
20428 }
20429
20430 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
20431 {
20432         ndr_print_struct(ndr, name, "spoolss_SetJob");
20433         ndr->depth++;
20434         if (flags & NDR_SET_VALUES) {
20435                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20436         }
20437         if (flags & NDR_IN) {
20438                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
20439                 ndr->depth++;
20440                 ndr_print_ptr(ndr, "handle", r->in.handle);
20441                 ndr->depth++;
20442                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20443                 ndr->depth--;
20444                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
20445                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
20446                 ndr->depth++;
20447                 if (r->in.ctr) {
20448                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
20449                 }
20450                 ndr->depth--;
20451                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
20452                 ndr->depth--;
20453         }
20454         if (flags & NDR_OUT) {
20455                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
20456                 ndr->depth++;
20457                 ndr_print_WERROR(ndr, "result", r->out.result);
20458                 ndr->depth--;
20459         }
20460         ndr->depth--;
20461 }
20462
20463 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
20464 {
20465         if (flags & NDR_IN) {
20466                 if (r->in.handle == NULL) {
20467                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20468                 }
20469                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20470                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
20471                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20472                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20473                 if (r->in.buffer) {
20474                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20475                 }
20476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20477         }
20478         if (flags & NDR_OUT) {
20479                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20480                 if (r->out.info) {
20481                         {
20482                                 struct ndr_push *_ndr_info;
20483                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20484                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20485                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20486                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20487                         }
20488                 }
20489                 if (r->out.needed == NULL) {
20490                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20491                 }
20492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20493                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20494         }
20495         return NDR_ERR_SUCCESS;
20496 }
20497
20498 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
20499 {
20500         uint32_t _ptr_buffer;
20501         uint32_t _ptr_info;
20502         TALLOC_CTX *_mem_save_handle_0;
20503         TALLOC_CTX *_mem_save_buffer_0;
20504         TALLOC_CTX *_mem_save_info_0;
20505         TALLOC_CTX *_mem_save_needed_0;
20506         if (flags & NDR_IN) {
20507                 ZERO_STRUCT(r->out);
20508
20509                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20510                         NDR_PULL_ALLOC(ndr, r->in.handle);
20511                 }
20512                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20513                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20514                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20515                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
20517                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20518                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20519                 if (_ptr_buffer) {
20520                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20521                 } else {
20522                         r->in.buffer = NULL;
20523                 }
20524                 if (r->in.buffer) {
20525                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20526                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20527                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20528                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20529                 }
20530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20531                 NDR_PULL_ALLOC(ndr, r->out.needed);
20532                 ZERO_STRUCTP(r->out.needed);
20533         }
20534         if (flags & NDR_OUT) {
20535                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20536                 if (_ptr_info) {
20537                         NDR_PULL_ALLOC(ndr, r->out.info);
20538                 } else {
20539                         r->out.info = NULL;
20540                 }
20541                 if (r->out.info) {
20542                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20543                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20544                         {
20545                                 struct ndr_pull *_ndr_info;
20546                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20547                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20548                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20549                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20550                         }
20551                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20552                 }
20553                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20554                         NDR_PULL_ALLOC(ndr, r->out.needed);
20555                 }
20556                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20557                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20559                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20560                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20561         }
20562         return NDR_ERR_SUCCESS;
20563 }
20564
20565 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
20566 {
20567         ndr_print_struct(ndr, name, "spoolss_GetJob");
20568         ndr->depth++;
20569         if (flags & NDR_SET_VALUES) {
20570                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20571         }
20572         if (flags & NDR_IN) {
20573                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
20574                 ndr->depth++;
20575                 ndr_print_ptr(ndr, "handle", r->in.handle);
20576                 ndr->depth++;
20577                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20578                 ndr->depth--;
20579                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
20580                 ndr_print_uint32(ndr, "level", r->in.level);
20581                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20582                 ndr->depth++;
20583                 if (r->in.buffer) {
20584                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20585                 }
20586                 ndr->depth--;
20587                 ndr_print_uint32(ndr, "offered", r->in.offered);
20588                 ndr->depth--;
20589         }
20590         if (flags & NDR_OUT) {
20591                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
20592                 ndr->depth++;
20593                 ndr_print_ptr(ndr, "info", r->out.info);
20594                 ndr->depth++;
20595                 if (r->out.info) {
20596                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20597                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
20598                 }
20599                 ndr->depth--;
20600                 ndr_print_ptr(ndr, "needed", r->out.needed);
20601                 ndr->depth++;
20602                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20603                 ndr->depth--;
20604                 ndr_print_WERROR(ndr, "result", r->out.result);
20605                 ndr->depth--;
20606         }
20607         ndr->depth--;
20608 }
20609
20610 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
20611 {
20612         if (flags & NDR_IN) {
20613                 if (r->in.handle == NULL) {
20614                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20615                 }
20616                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20617                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
20618                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
20619                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20620                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20621                 if (r->in.buffer) {
20622                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20623                 }
20624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20625         }
20626         if (flags & NDR_OUT) {
20627                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20628                 if (r->out.info) {
20629                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20630                 }
20631                 if (r->out.needed == NULL) {
20632                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20633                 }
20634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20635                 if (r->out.count == NULL) {
20636                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20637                 }
20638                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20639                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20640         }
20641         return NDR_ERR_SUCCESS;
20642 }
20643
20644 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
20645 {
20646         uint32_t _ptr_buffer;
20647         uint32_t _ptr_info;
20648         TALLOC_CTX *_mem_save_handle_0;
20649         TALLOC_CTX *_mem_save_buffer_0;
20650         TALLOC_CTX *_mem_save_info_0;
20651         TALLOC_CTX *_mem_save_needed_0;
20652         TALLOC_CTX *_mem_save_count_0;
20653         if (flags & NDR_IN) {
20654                 ZERO_STRUCT(r->out);
20655
20656                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20657                         NDR_PULL_ALLOC(ndr, r->in.handle);
20658                 }
20659                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20660                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20661                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20662                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20663                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
20664                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
20665                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20667                 if (_ptr_buffer) {
20668                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20669                 } else {
20670                         r->in.buffer = NULL;
20671                 }
20672                 if (r->in.buffer) {
20673                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20674                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20675                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20676                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20677                 }
20678                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20679                 NDR_PULL_ALLOC(ndr, r->out.needed);
20680                 ZERO_STRUCTP(r->out.needed);
20681                 NDR_PULL_ALLOC(ndr, r->out.count);
20682                 ZERO_STRUCTP(r->out.count);
20683         }
20684         if (flags & NDR_OUT) {
20685                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20686                 if (_ptr_info) {
20687                         NDR_PULL_ALLOC(ndr, r->out.info);
20688                 } else {
20689                         r->out.info = NULL;
20690                 }
20691                 if (r->out.info) {
20692                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20693                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20694                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20695                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20696                 }
20697                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20698                         NDR_PULL_ALLOC(ndr, r->out.needed);
20699                 }
20700                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20701                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20702                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20703                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20704                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20705                         NDR_PULL_ALLOC(ndr, r->out.count);
20706                 }
20707                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20708                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20709                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20710                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20711                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20712         }
20713         return NDR_ERR_SUCCESS;
20714 }
20715
20716 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
20717 {
20718         uint32_t cntr_info_0;
20719         if (flags & NDR_IN) {
20720                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20721                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20722         }
20723         if (flags & NDR_OUT) {
20724                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20725                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20726                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20727                 }
20728                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20729                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20730                 }
20731         }
20732         return NDR_ERR_SUCCESS;
20733 }
20734
20735 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
20736 {
20737         uint32_t cntr_info_0;
20738         TALLOC_CTX *_mem_save_info_0;
20739         if (flags & NDR_IN) {
20740                 ZERO_STRUCT(r->out);
20741
20742                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20744         }
20745         if (flags & NDR_OUT) {
20746                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20747                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20748                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20749                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20750                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20751                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20752                 }
20753                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20754                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20755                 }
20756                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20757         }
20758         return NDR_ERR_SUCCESS;
20759 }
20760
20761 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
20762 {
20763         uint32_t cntr_info_2;
20764         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
20765         ndr->depth++;
20766         if (flags & NDR_SET_VALUES) {
20767                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20768         }
20769         if (flags & NDR_IN) {
20770                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
20771                 ndr->depth++;
20772                 ndr_print_ptr(ndr, "handle", r->in.handle);
20773                 ndr->depth++;
20774                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20775                 ndr->depth--;
20776                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
20777                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
20778                 ndr_print_uint32(ndr, "level", r->in.level);
20779                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20780                 ndr->depth++;
20781                 if (r->in.buffer) {
20782                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20783                 }
20784                 ndr->depth--;
20785                 ndr_print_uint32(ndr, "offered", r->in.offered);
20786                 ndr->depth--;
20787         }
20788         if (flags & NDR_OUT) {
20789                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
20790                 ndr->depth++;
20791                 ndr_print_ptr(ndr, "count", r->out.count);
20792                 ndr->depth++;
20793                 ndr_print_uint32(ndr, "count", *r->out.count);
20794                 ndr->depth--;
20795                 ndr_print_ptr(ndr, "info", r->out.info);
20796                 ndr->depth++;
20797                 ndr_print_ptr(ndr, "info", *r->out.info);
20798                 ndr->depth++;
20799                 if (*r->out.info) {
20800                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20801                         ndr->depth++;
20802                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20803                                 char *idx_2=NULL;
20804                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20805                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20806                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20807                                         free(idx_2);
20808                                 }
20809                         }
20810                         ndr->depth--;
20811                 }
20812                 ndr->depth--;
20813                 ndr->depth--;
20814                 ndr_print_ptr(ndr, "needed", r->out.needed);
20815                 ndr->depth++;
20816                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20817                 ndr->depth--;
20818                 ndr_print_WERROR(ndr, "result", r->out.result);
20819                 ndr->depth--;
20820         }
20821         ndr->depth--;
20822 }
20823
20824 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
20825 {
20826         if (flags & NDR_IN) {
20827                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20828                 if (r->in.server) {
20829                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20830                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20831                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20832                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20833                 }
20834                 if (r->in.info_ctr == NULL) {
20835                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20836                 }
20837                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20838                 if (r->in.devmode_ctr == NULL) {
20839                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20840                 }
20841                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20842                 if (r->in.secdesc_ctr == NULL) {
20843                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20844                 }
20845                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20846         }
20847         if (flags & NDR_OUT) {
20848                 if (r->out.handle == NULL) {
20849                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20850                 }
20851                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20852                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20853         }
20854         return NDR_ERR_SUCCESS;
20855 }
20856
20857 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
20858 {
20859         uint32_t _ptr_server;
20860         TALLOC_CTX *_mem_save_server_0;
20861         TALLOC_CTX *_mem_save_info_ctr_0;
20862         TALLOC_CTX *_mem_save_devmode_ctr_0;
20863         TALLOC_CTX *_mem_save_secdesc_ctr_0;
20864         TALLOC_CTX *_mem_save_handle_0;
20865         if (flags & NDR_IN) {
20866                 ZERO_STRUCT(r->out);
20867
20868                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20869                 if (_ptr_server) {
20870                         NDR_PULL_ALLOC(ndr, r->in.server);
20871                 } else {
20872                         r->in.server = NULL;
20873                 }
20874                 if (r->in.server) {
20875                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20876                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20877                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20878                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20879                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20880                                 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));
20881                         }
20882                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20883                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20884                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20885                 }
20886                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20887                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20888                 }
20889                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20890                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20891                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20892                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20893                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20894                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
20895                 }
20896                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20897                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
20898                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20899                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20900                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20901                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
20902                 }
20903                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20904                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
20905                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20906                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20907                 NDR_PULL_ALLOC(ndr, r->out.handle);
20908                 ZERO_STRUCTP(r->out.handle);
20909         }
20910         if (flags & NDR_OUT) {
20911                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20912                         NDR_PULL_ALLOC(ndr, r->out.handle);
20913                 }
20914                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20915                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20916                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20917                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20918                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20919         }
20920         return NDR_ERR_SUCCESS;
20921 }
20922
20923 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
20924 {
20925         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
20926         ndr->depth++;
20927         if (flags & NDR_SET_VALUES) {
20928                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20929         }
20930         if (flags & NDR_IN) {
20931                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
20932                 ndr->depth++;
20933                 ndr_print_ptr(ndr, "server", r->in.server);
20934                 ndr->depth++;
20935                 if (r->in.server) {
20936                         ndr_print_string(ndr, "server", r->in.server);
20937                 }
20938                 ndr->depth--;
20939                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
20940                 ndr->depth++;
20941                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
20942                 ndr->depth--;
20943                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
20944                 ndr->depth++;
20945                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
20946                 ndr->depth--;
20947                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20948                 ndr->depth++;
20949                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20950                 ndr->depth--;
20951                 ndr->depth--;
20952         }
20953         if (flags & NDR_OUT) {
20954                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
20955                 ndr->depth++;
20956                 ndr_print_ptr(ndr, "handle", r->out.handle);
20957                 ndr->depth++;
20958                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20959                 ndr->depth--;
20960                 ndr_print_WERROR(ndr, "result", r->out.result);
20961                 ndr->depth--;
20962         }
20963         ndr->depth--;
20964 }
20965
20966 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
20967 {
20968         if (flags & NDR_IN) {
20969                 if (r->in.handle == NULL) {
20970                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20971                 }
20972                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20973         }
20974         if (flags & NDR_OUT) {
20975                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20976         }
20977         return NDR_ERR_SUCCESS;
20978 }
20979
20980 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
20981 {
20982         TALLOC_CTX *_mem_save_handle_0;
20983         if (flags & NDR_IN) {
20984                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20985                         NDR_PULL_ALLOC(ndr, r->in.handle);
20986                 }
20987                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20988                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20989                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20990                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20991         }
20992         if (flags & NDR_OUT) {
20993                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20994         }
20995         return NDR_ERR_SUCCESS;
20996 }
20997
20998 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
20999 {
21000         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
21001         ndr->depth++;
21002         if (flags & NDR_SET_VALUES) {
21003                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21004         }
21005         if (flags & NDR_IN) {
21006                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
21007                 ndr->depth++;
21008                 ndr_print_ptr(ndr, "handle", r->in.handle);
21009                 ndr->depth++;
21010                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21011                 ndr->depth--;
21012                 ndr->depth--;
21013         }
21014         if (flags & NDR_OUT) {
21015                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
21016                 ndr->depth++;
21017                 ndr_print_WERROR(ndr, "result", r->out.result);
21018                 ndr->depth--;
21019         }
21020         ndr->depth--;
21021 }
21022
21023 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
21024 {
21025         if (flags & NDR_IN) {
21026                 if (r->in.handle == NULL) {
21027                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21028                 }
21029                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21030                 if (r->in.info_ctr == NULL) {
21031                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21032                 }
21033                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21034                 if (r->in.devmode_ctr == NULL) {
21035                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21036                 }
21037                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21038                 if (r->in.secdesc_ctr == NULL) {
21039                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21040                 }
21041                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21042                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
21043         }
21044         if (flags & NDR_OUT) {
21045                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21046         }
21047         return NDR_ERR_SUCCESS;
21048 }
21049
21050 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
21051 {
21052         TALLOC_CTX *_mem_save_handle_0;
21053         TALLOC_CTX *_mem_save_info_ctr_0;
21054         TALLOC_CTX *_mem_save_devmode_ctr_0;
21055         TALLOC_CTX *_mem_save_secdesc_ctr_0;
21056         if (flags & NDR_IN) {
21057                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21058                         NDR_PULL_ALLOC(ndr, r->in.handle);
21059                 }
21060                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21061                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21062                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21063                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21064                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21065                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21066                 }
21067                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21068                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21069                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21070                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21071                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21072                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21073                 }
21074                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21075                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21076                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21077                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21078                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21079                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21080                 }
21081                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21082                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21083                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21084                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21085                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
21086         }
21087         if (flags & NDR_OUT) {
21088                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21089         }
21090         return NDR_ERR_SUCCESS;
21091 }
21092
21093 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
21094 {
21095         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
21096         ndr->depth++;
21097         if (flags & NDR_SET_VALUES) {
21098                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21099         }
21100         if (flags & NDR_IN) {
21101                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
21102                 ndr->depth++;
21103                 ndr_print_ptr(ndr, "handle", r->in.handle);
21104                 ndr->depth++;
21105                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21106                 ndr->depth--;
21107                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21108                 ndr->depth++;
21109                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21110                 ndr->depth--;
21111                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21112                 ndr->depth++;
21113                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21114                 ndr->depth--;
21115                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21116                 ndr->depth++;
21117                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21118                 ndr->depth--;
21119                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
21120                 ndr->depth--;
21121         }
21122         if (flags & NDR_OUT) {
21123                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
21124                 ndr->depth++;
21125                 ndr_print_WERROR(ndr, "result", r->out.result);
21126                 ndr->depth--;
21127         }
21128         ndr->depth--;
21129 }
21130
21131 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
21132 {
21133         if (flags & NDR_IN) {
21134                 if (r->in.handle == NULL) {
21135                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21136                 }
21137                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21138                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21139                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21140                 if (r->in.buffer) {
21141                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21142                 }
21143                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21144         }
21145         if (flags & NDR_OUT) {
21146                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21147                 if (r->out.info) {
21148                         {
21149                                 struct ndr_push *_ndr_info;
21150                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21151                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21152                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21153                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21154                         }
21155                 }
21156                 if (r->out.needed == NULL) {
21157                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21158                 }
21159                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21160                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21161         }
21162         return NDR_ERR_SUCCESS;
21163 }
21164
21165 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
21166 {
21167         uint32_t _ptr_buffer;
21168         uint32_t _ptr_info;
21169         TALLOC_CTX *_mem_save_handle_0;
21170         TALLOC_CTX *_mem_save_buffer_0;
21171         TALLOC_CTX *_mem_save_info_0;
21172         TALLOC_CTX *_mem_save_needed_0;
21173         if (flags & NDR_IN) {
21174                 ZERO_STRUCT(r->out);
21175
21176                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21177                         NDR_PULL_ALLOC(ndr, r->in.handle);
21178                 }
21179                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21180                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21181                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21182                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21183                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21184                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21185                 if (_ptr_buffer) {
21186                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21187                 } else {
21188                         r->in.buffer = NULL;
21189                 }
21190                 if (r->in.buffer) {
21191                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21192                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21193                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21194                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21195                 }
21196                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21197                 NDR_PULL_ALLOC(ndr, r->out.needed);
21198                 ZERO_STRUCTP(r->out.needed);
21199         }
21200         if (flags & NDR_OUT) {
21201                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21202                 if (_ptr_info) {
21203                         NDR_PULL_ALLOC(ndr, r->out.info);
21204                 } else {
21205                         r->out.info = NULL;
21206                 }
21207                 if (r->out.info) {
21208                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21209                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21210                         {
21211                                 struct ndr_pull *_ndr_info;
21212                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21213                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21214                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21215                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21216                         }
21217                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21218                 }
21219                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21220                         NDR_PULL_ALLOC(ndr, r->out.needed);
21221                 }
21222                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21223                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21225                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21226                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21227         }
21228         return NDR_ERR_SUCCESS;
21229 }
21230
21231 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
21232 {
21233         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
21234         ndr->depth++;
21235         if (flags & NDR_SET_VALUES) {
21236                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21237         }
21238         if (flags & NDR_IN) {
21239                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
21240                 ndr->depth++;
21241                 ndr_print_ptr(ndr, "handle", r->in.handle);
21242                 ndr->depth++;
21243                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21244                 ndr->depth--;
21245                 ndr_print_uint32(ndr, "level", r->in.level);
21246                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21247                 ndr->depth++;
21248                 if (r->in.buffer) {
21249                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21250                 }
21251                 ndr->depth--;
21252                 ndr_print_uint32(ndr, "offered", r->in.offered);
21253                 ndr->depth--;
21254         }
21255         if (flags & NDR_OUT) {
21256                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
21257                 ndr->depth++;
21258                 ndr_print_ptr(ndr, "info", r->out.info);
21259                 ndr->depth++;
21260                 if (r->out.info) {
21261                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21262                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
21263                 }
21264                 ndr->depth--;
21265                 ndr_print_ptr(ndr, "needed", r->out.needed);
21266                 ndr->depth++;
21267                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21268                 ndr->depth--;
21269                 ndr_print_WERROR(ndr, "result", r->out.result);
21270                 ndr->depth--;
21271         }
21272         ndr->depth--;
21273 }
21274
21275 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
21276 {
21277         if (flags & NDR_IN) {
21278                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
21279                 if (r->in.servername) {
21280                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21281                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21282                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21283                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21284                 }
21285                 if (r->in.info_ctr == NULL) {
21286                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21287                 }
21288                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21289         }
21290         if (flags & NDR_OUT) {
21291                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21292         }
21293         return NDR_ERR_SUCCESS;
21294 }
21295
21296 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
21297 {
21298         uint32_t _ptr_servername;
21299         TALLOC_CTX *_mem_save_servername_0;
21300         TALLOC_CTX *_mem_save_info_ctr_0;
21301         if (flags & NDR_IN) {
21302                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
21303                 if (_ptr_servername) {
21304                         NDR_PULL_ALLOC(ndr, r->in.servername);
21305                 } else {
21306                         r->in.servername = NULL;
21307                 }
21308                 if (r->in.servername) {
21309                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
21310                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
21311                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
21312                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
21313                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
21314                                 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));
21315                         }
21316                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
21317                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
21318                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
21319                 }
21320                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21321                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21322                 }
21323                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21324                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21325                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21326                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21327         }
21328         if (flags & NDR_OUT) {
21329                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21330         }
21331         return NDR_ERR_SUCCESS;
21332 }
21333
21334 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
21335 {
21336         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
21337         ndr->depth++;
21338         if (flags & NDR_SET_VALUES) {
21339                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21340         }
21341         if (flags & NDR_IN) {
21342                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
21343                 ndr->depth++;
21344                 ndr_print_ptr(ndr, "servername", r->in.servername);
21345                 ndr->depth++;
21346                 if (r->in.servername) {
21347                         ndr_print_string(ndr, "servername", r->in.servername);
21348                 }
21349                 ndr->depth--;
21350                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21351                 ndr->depth++;
21352                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21353                 ndr->depth--;
21354                 ndr->depth--;
21355         }
21356         if (flags & NDR_OUT) {
21357                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
21358                 ndr->depth++;
21359                 ndr_print_WERROR(ndr, "result", r->out.result);
21360                 ndr->depth--;
21361         }
21362         ndr->depth--;
21363 }
21364
21365 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
21366 {
21367         if (flags & NDR_IN) {
21368                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21369                 if (r->in.server) {
21370                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21371                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21372                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21373                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21374                 }
21375                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21376                 if (r->in.environment) {
21377                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21378                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21379                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21380                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21381                 }
21382                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21383                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21384                 if (r->in.buffer) {
21385                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21386                 }
21387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21388         }
21389         if (flags & NDR_OUT) {
21390                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21391                 if (r->out.info) {
21392                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
21393                 }
21394                 if (r->out.needed == NULL) {
21395                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21396                 }
21397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21398                 if (r->out.count == NULL) {
21399                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21400                 }
21401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21402                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21403         }
21404         return NDR_ERR_SUCCESS;
21405 }
21406
21407 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
21408 {
21409         uint32_t _ptr_server;
21410         uint32_t _ptr_environment;
21411         uint32_t _ptr_buffer;
21412         uint32_t _ptr_info;
21413         TALLOC_CTX *_mem_save_server_0;
21414         TALLOC_CTX *_mem_save_environment_0;
21415         TALLOC_CTX *_mem_save_buffer_0;
21416         TALLOC_CTX *_mem_save_info_0;
21417         TALLOC_CTX *_mem_save_needed_0;
21418         TALLOC_CTX *_mem_save_count_0;
21419         if (flags & NDR_IN) {
21420                 ZERO_STRUCT(r->out);
21421
21422                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21423                 if (_ptr_server) {
21424                         NDR_PULL_ALLOC(ndr, r->in.server);
21425                 } else {
21426                         r->in.server = NULL;
21427                 }
21428                 if (r->in.server) {
21429                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21430                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21431                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21432                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21433                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21434                                 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));
21435                         }
21436                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21437                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21438                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21439                 }
21440                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21441                 if (_ptr_environment) {
21442                         NDR_PULL_ALLOC(ndr, r->in.environment);
21443                 } else {
21444                         r->in.environment = NULL;
21445                 }
21446                 if (r->in.environment) {
21447                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21448                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21449                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21450                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21451                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21452                                 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));
21453                         }
21454                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21455                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21456                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21457                 }
21458                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21459                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21460                 if (_ptr_buffer) {
21461                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21462                 } else {
21463                         r->in.buffer = NULL;
21464                 }
21465                 if (r->in.buffer) {
21466                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21467                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21468                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21469                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21470                 }
21471                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21472                 NDR_PULL_ALLOC(ndr, r->out.needed);
21473                 ZERO_STRUCTP(r->out.needed);
21474                 NDR_PULL_ALLOC(ndr, r->out.count);
21475                 ZERO_STRUCTP(r->out.count);
21476         }
21477         if (flags & NDR_OUT) {
21478                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21479                 if (_ptr_info) {
21480                         NDR_PULL_ALLOC(ndr, r->out.info);
21481                 } else {
21482                         r->out.info = NULL;
21483                 }
21484                 if (r->out.info) {
21485                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21486                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21487                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
21488                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21489                 }
21490                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21491                         NDR_PULL_ALLOC(ndr, r->out.needed);
21492                 }
21493                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21494                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21496                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21497                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21498                         NDR_PULL_ALLOC(ndr, r->out.count);
21499                 }
21500                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21501                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21502                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21503                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21504                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21505         }
21506         return NDR_ERR_SUCCESS;
21507 }
21508
21509 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
21510 {
21511         uint32_t cntr_info_0;
21512         if (flags & NDR_IN) {
21513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
21515         }
21516         if (flags & NDR_OUT) {
21517                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21518                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21519                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21520                 }
21521                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21522                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21523                 }
21524         }
21525         return NDR_ERR_SUCCESS;
21526 }
21527
21528 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
21529 {
21530         uint32_t cntr_info_0;
21531         TALLOC_CTX *_mem_save_info_0;
21532         if (flags & NDR_IN) {
21533                 ZERO_STRUCT(r->out);
21534
21535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21537         }
21538         if (flags & NDR_OUT) {
21539                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
21540                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21541                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21542                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21543                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21544                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21545                 }
21546                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21547                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21548                 }
21549                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21550         }
21551         return NDR_ERR_SUCCESS;
21552 }
21553
21554 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
21555 {
21556         uint32_t cntr_info_2;
21557         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
21558         ndr->depth++;
21559         if (flags & NDR_SET_VALUES) {
21560                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21561         }
21562         if (flags & NDR_IN) {
21563                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
21564                 ndr->depth++;
21565                 ndr_print_ptr(ndr, "server", r->in.server);
21566                 ndr->depth++;
21567                 if (r->in.server) {
21568                         ndr_print_string(ndr, "server", r->in.server);
21569                 }
21570                 ndr->depth--;
21571                 ndr_print_ptr(ndr, "environment", r->in.environment);
21572                 ndr->depth++;
21573                 if (r->in.environment) {
21574                         ndr_print_string(ndr, "environment", r->in.environment);
21575                 }
21576                 ndr->depth--;
21577                 ndr_print_uint32(ndr, "level", r->in.level);
21578                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21579                 ndr->depth++;
21580                 if (r->in.buffer) {
21581                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21582                 }
21583                 ndr->depth--;
21584                 ndr_print_uint32(ndr, "offered", r->in.offered);
21585                 ndr->depth--;
21586         }
21587         if (flags & NDR_OUT) {
21588                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
21589                 ndr->depth++;
21590                 ndr_print_ptr(ndr, "count", r->out.count);
21591                 ndr->depth++;
21592                 ndr_print_uint32(ndr, "count", *r->out.count);
21593                 ndr->depth--;
21594                 ndr_print_ptr(ndr, "info", r->out.info);
21595                 ndr->depth++;
21596                 ndr_print_ptr(ndr, "info", *r->out.info);
21597                 ndr->depth++;
21598                 if (*r->out.info) {
21599                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21600                         ndr->depth++;
21601                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21602                                 char *idx_2=NULL;
21603                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21604                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21605                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21606                                         free(idx_2);
21607                                 }
21608                         }
21609                         ndr->depth--;
21610                 }
21611                 ndr->depth--;
21612                 ndr->depth--;
21613                 ndr_print_ptr(ndr, "needed", r->out.needed);
21614                 ndr->depth++;
21615                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21616                 ndr->depth--;
21617                 ndr_print_WERROR(ndr, "result", r->out.result);
21618                 ndr->depth--;
21619         }
21620         ndr->depth--;
21621 }
21622
21623 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
21624 {
21625         if (flags & NDR_IN) {
21626                 if (r->in.handle == NULL) {
21627                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21628                 }
21629                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21630                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
21631                 if (r->in.architecture) {
21632                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21633                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21634                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21635                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21636                 }
21637                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21638                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21639                 if (r->in.buffer) {
21640                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21641                 }
21642                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21643         }
21644         if (flags & NDR_OUT) {
21645                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21646                 if (r->out.info) {
21647                         {
21648                                 struct ndr_push *_ndr_info;
21649                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21650                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21651                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21652                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21653                         }
21654                 }
21655                 if (r->out.needed == NULL) {
21656                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21657                 }
21658                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21659                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21660         }
21661         return NDR_ERR_SUCCESS;
21662 }
21663
21664 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
21665 {
21666         uint32_t _ptr_architecture;
21667         uint32_t _ptr_buffer;
21668         uint32_t _ptr_info;
21669         TALLOC_CTX *_mem_save_handle_0;
21670         TALLOC_CTX *_mem_save_architecture_0;
21671         TALLOC_CTX *_mem_save_buffer_0;
21672         TALLOC_CTX *_mem_save_info_0;
21673         TALLOC_CTX *_mem_save_needed_0;
21674         if (flags & NDR_IN) {
21675                 ZERO_STRUCT(r->out);
21676
21677                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21678                         NDR_PULL_ALLOC(ndr, r->in.handle);
21679                 }
21680                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21681                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21682                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21683                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21684                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
21685                 if (_ptr_architecture) {
21686                         NDR_PULL_ALLOC(ndr, r->in.architecture);
21687                 } else {
21688                         r->in.architecture = NULL;
21689                 }
21690                 if (r->in.architecture) {
21691                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
21692                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
21693                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
21694                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
21695                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
21696                                 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));
21697                         }
21698                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
21699                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
21700                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
21701                 }
21702                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21703                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21704                 if (_ptr_buffer) {
21705                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21706                 } else {
21707                         r->in.buffer = NULL;
21708                 }
21709                 if (r->in.buffer) {
21710                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21711                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21712                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21713                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21714                 }
21715                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21716                 NDR_PULL_ALLOC(ndr, r->out.needed);
21717                 ZERO_STRUCTP(r->out.needed);
21718         }
21719         if (flags & NDR_OUT) {
21720                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21721                 if (_ptr_info) {
21722                         NDR_PULL_ALLOC(ndr, r->out.info);
21723                 } else {
21724                         r->out.info = NULL;
21725                 }
21726                 if (r->out.info) {
21727                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21728                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21729                         {
21730                                 struct ndr_pull *_ndr_info;
21731                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21732                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21733                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21734                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21735                         }
21736                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21737                 }
21738                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21739                         NDR_PULL_ALLOC(ndr, r->out.needed);
21740                 }
21741                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21742                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21744                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21745                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21746         }
21747         return NDR_ERR_SUCCESS;
21748 }
21749
21750 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
21751 {
21752         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
21753         ndr->depth++;
21754         if (flags & NDR_SET_VALUES) {
21755                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21756         }
21757         if (flags & NDR_IN) {
21758                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
21759                 ndr->depth++;
21760                 ndr_print_ptr(ndr, "handle", r->in.handle);
21761                 ndr->depth++;
21762                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21763                 ndr->depth--;
21764                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
21765                 ndr->depth++;
21766                 if (r->in.architecture) {
21767                         ndr_print_string(ndr, "architecture", r->in.architecture);
21768                 }
21769                 ndr->depth--;
21770                 ndr_print_uint32(ndr, "level", r->in.level);
21771                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21772                 ndr->depth++;
21773                 if (r->in.buffer) {
21774                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21775                 }
21776                 ndr->depth--;
21777                 ndr_print_uint32(ndr, "offered", r->in.offered);
21778                 ndr->depth--;
21779         }
21780         if (flags & NDR_OUT) {
21781                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
21782                 ndr->depth++;
21783                 ndr_print_ptr(ndr, "info", r->out.info);
21784                 ndr->depth++;
21785                 if (r->out.info) {
21786                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21787                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
21788                 }
21789                 ndr->depth--;
21790                 ndr_print_ptr(ndr, "needed", r->out.needed);
21791                 ndr->depth++;
21792                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21793                 ndr->depth--;
21794                 ndr_print_WERROR(ndr, "result", r->out.result);
21795                 ndr->depth--;
21796         }
21797         ndr->depth--;
21798 }
21799
21800 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
21801 {
21802         if (flags & NDR_IN) {
21803                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21804                 if (r->in.server) {
21805                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21806                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21807                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21808                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21809                 }
21810                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21811                 if (r->in.environment) {
21812                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21813                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21814                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21815                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21816                 }
21817                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21818                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21819                 if (r->in.buffer) {
21820                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21821                 }
21822                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21823         }
21824         if (flags & NDR_OUT) {
21825                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21826                 if (r->out.info) {
21827                         {
21828                                 struct ndr_push *_ndr_info;
21829                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21830                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21831                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21832                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21833                         }
21834                 }
21835                 if (r->out.needed == NULL) {
21836                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21837                 }
21838                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21839                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21840         }
21841         return NDR_ERR_SUCCESS;
21842 }
21843
21844 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
21845 {
21846         uint32_t _ptr_server;
21847         uint32_t _ptr_environment;
21848         uint32_t _ptr_buffer;
21849         uint32_t _ptr_info;
21850         TALLOC_CTX *_mem_save_server_0;
21851         TALLOC_CTX *_mem_save_environment_0;
21852         TALLOC_CTX *_mem_save_buffer_0;
21853         TALLOC_CTX *_mem_save_info_0;
21854         TALLOC_CTX *_mem_save_needed_0;
21855         if (flags & NDR_IN) {
21856                 ZERO_STRUCT(r->out);
21857
21858                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21859                 if (_ptr_server) {
21860                         NDR_PULL_ALLOC(ndr, r->in.server);
21861                 } else {
21862                         r->in.server = NULL;
21863                 }
21864                 if (r->in.server) {
21865                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21866                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21867                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21868                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21869                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21870                                 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));
21871                         }
21872                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21873                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21874                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21875                 }
21876                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21877                 if (_ptr_environment) {
21878                         NDR_PULL_ALLOC(ndr, r->in.environment);
21879                 } else {
21880                         r->in.environment = NULL;
21881                 }
21882                 if (r->in.environment) {
21883                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21884                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21885                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21886                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21887                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21888                                 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));
21889                         }
21890                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21891                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21892                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21893                 }
21894                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21895                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21896                 if (_ptr_buffer) {
21897                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21898                 } else {
21899                         r->in.buffer = NULL;
21900                 }
21901                 if (r->in.buffer) {
21902                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21903                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21904                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21905                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21906                 }
21907                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21908                 NDR_PULL_ALLOC(ndr, r->out.needed);
21909                 ZERO_STRUCTP(r->out.needed);
21910         }
21911         if (flags & NDR_OUT) {
21912                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21913                 if (_ptr_info) {
21914                         NDR_PULL_ALLOC(ndr, r->out.info);
21915                 } else {
21916                         r->out.info = NULL;
21917                 }
21918                 if (r->out.info) {
21919                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21920                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21921                         {
21922                                 struct ndr_pull *_ndr_info;
21923                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21924                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21925                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21926                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21927                         }
21928                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21929                 }
21930                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21931                         NDR_PULL_ALLOC(ndr, r->out.needed);
21932                 }
21933                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21934                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21936                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21937                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21938         }
21939         return NDR_ERR_SUCCESS;
21940 }
21941
21942 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
21943 {
21944         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
21945         ndr->depth++;
21946         if (flags & NDR_SET_VALUES) {
21947                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21948         }
21949         if (flags & NDR_IN) {
21950                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
21951                 ndr->depth++;
21952                 ndr_print_ptr(ndr, "server", r->in.server);
21953                 ndr->depth++;
21954                 if (r->in.server) {
21955                         ndr_print_string(ndr, "server", r->in.server);
21956                 }
21957                 ndr->depth--;
21958                 ndr_print_ptr(ndr, "environment", r->in.environment);
21959                 ndr->depth++;
21960                 if (r->in.environment) {
21961                         ndr_print_string(ndr, "environment", r->in.environment);
21962                 }
21963                 ndr->depth--;
21964                 ndr_print_uint32(ndr, "level", r->in.level);
21965                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21966                 ndr->depth++;
21967                 if (r->in.buffer) {
21968                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21969                 }
21970                 ndr->depth--;
21971                 ndr_print_uint32(ndr, "offered", r->in.offered);
21972                 ndr->depth--;
21973         }
21974         if (flags & NDR_OUT) {
21975                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
21976                 ndr->depth++;
21977                 ndr_print_ptr(ndr, "info", r->out.info);
21978                 ndr->depth++;
21979                 if (r->out.info) {
21980                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21981                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
21982                 }
21983                 ndr->depth--;
21984                 ndr_print_ptr(ndr, "needed", r->out.needed);
21985                 ndr->depth++;
21986                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21987                 ndr->depth--;
21988                 ndr_print_WERROR(ndr, "result", r->out.result);
21989                 ndr->depth--;
21990         }
21991         ndr->depth--;
21992 }
21993
21994 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
21995 {
21996         if (flags & NDR_IN) {
21997                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21998                 if (r->in.server) {
21999                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22000                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22001                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22002                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22003                 }
22004                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22005                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22006                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22007                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22008                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22009                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22010                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22011                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22012         }
22013         if (flags & NDR_OUT) {
22014                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22015         }
22016         return NDR_ERR_SUCCESS;
22017 }
22018
22019 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
22020 {
22021         uint32_t _ptr_server;
22022         TALLOC_CTX *_mem_save_server_0;
22023         if (flags & NDR_IN) {
22024                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22025                 if (_ptr_server) {
22026                         NDR_PULL_ALLOC(ndr, r->in.server);
22027                 } else {
22028                         r->in.server = NULL;
22029                 }
22030                 if (r->in.server) {
22031                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22032                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22033                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22034                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22035                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22036                                 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));
22037                         }
22038                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22039                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22040                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22041                 }
22042                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22043                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22044                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22045                         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));
22046                 }
22047                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22048                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22049                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
22050                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
22051                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
22052                         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));
22053                 }
22054                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
22055                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
22056         }
22057         if (flags & NDR_OUT) {
22058                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22059         }
22060         return NDR_ERR_SUCCESS;
22061 }
22062
22063 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
22064 {
22065         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
22066         ndr->depth++;
22067         if (flags & NDR_SET_VALUES) {
22068                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22069         }
22070         if (flags & NDR_IN) {
22071                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
22072                 ndr->depth++;
22073                 ndr_print_ptr(ndr, "server", r->in.server);
22074                 ndr->depth++;
22075                 if (r->in.server) {
22076                         ndr_print_string(ndr, "server", r->in.server);
22077                 }
22078                 ndr->depth--;
22079                 ndr_print_string(ndr, "architecture", r->in.architecture);
22080                 ndr_print_string(ndr, "driver", r->in.driver);
22081                 ndr->depth--;
22082         }
22083         if (flags & NDR_OUT) {
22084                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
22085                 ndr->depth++;
22086                 ndr_print_WERROR(ndr, "result", r->out.result);
22087                 ndr->depth--;
22088         }
22089         ndr->depth--;
22090 }
22091
22092 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
22093 {
22094         if (flags & NDR_IN) {
22095                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22096                 if (r->in.server) {
22097                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22098                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22099                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22100                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22101                 }
22102                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22103                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22104                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22105                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22106                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22107                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22108                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22109                 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));
22110                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22111                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22112                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22113                 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));
22114         }
22115         if (flags & NDR_OUT) {
22116                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22117         }
22118         return NDR_ERR_SUCCESS;
22119 }
22120
22121 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
22122 {
22123         uint32_t _ptr_server;
22124         TALLOC_CTX *_mem_save_server_0;
22125         if (flags & NDR_IN) {
22126                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22127                 if (_ptr_server) {
22128                         NDR_PULL_ALLOC(ndr, r->in.server);
22129                 } else {
22130                         r->in.server = NULL;
22131                 }
22132                 if (r->in.server) {
22133                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22134                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22135                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22136                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22137                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22138                                 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));
22139                         }
22140                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22141                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22142                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22143                 }
22144                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22145                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22146                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22147                         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));
22148                 }
22149                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22150                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22151                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
22152                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
22153                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
22154                         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));
22155                 }
22156                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
22157                 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));
22158                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
22159                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
22160                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
22161                         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));
22162                 }
22163                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
22164                 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));
22165         }
22166         if (flags & NDR_OUT) {
22167                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22168         }
22169         return NDR_ERR_SUCCESS;
22170 }
22171
22172 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
22173 {
22174         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
22175         ndr->depth++;
22176         if (flags & NDR_SET_VALUES) {
22177                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22178         }
22179         if (flags & NDR_IN) {
22180                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
22181                 ndr->depth++;
22182                 ndr_print_ptr(ndr, "server", r->in.server);
22183                 ndr->depth++;
22184                 if (r->in.server) {
22185                         ndr_print_string(ndr, "server", r->in.server);
22186                 }
22187                 ndr->depth--;
22188                 ndr_print_string(ndr, "architecture", r->in.architecture);
22189                 ndr_print_string(ndr, "path_name", r->in.path_name);
22190                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
22191                 ndr->depth--;
22192         }
22193         if (flags & NDR_OUT) {
22194                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
22195                 ndr->depth++;
22196                 ndr_print_WERROR(ndr, "result", r->out.result);
22197                 ndr->depth--;
22198         }
22199         ndr->depth--;
22200 }
22201
22202 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
22203 {
22204         if (flags & NDR_IN) {
22205                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22206                 if (r->in.servername) {
22207                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22208                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22209                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22210                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22211                 }
22212                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22213                 if (r->in.environment) {
22214                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22215                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22216                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22217                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22218                 }
22219                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22220                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22221                 if (r->in.buffer) {
22222                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22223                 }
22224                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22225         }
22226         if (flags & NDR_OUT) {
22227                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22228                 if (r->out.info) {
22229                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22230                 }
22231                 if (r->out.needed == NULL) {
22232                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22233                 }
22234                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22235                 if (r->out.count == NULL) {
22236                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22237                 }
22238                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22239                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22240         }
22241         return NDR_ERR_SUCCESS;
22242 }
22243
22244 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
22245 {
22246         uint32_t _ptr_servername;
22247         uint32_t _ptr_environment;
22248         uint32_t _ptr_buffer;
22249         uint32_t _ptr_info;
22250         TALLOC_CTX *_mem_save_servername_0;
22251         TALLOC_CTX *_mem_save_environment_0;
22252         TALLOC_CTX *_mem_save_buffer_0;
22253         TALLOC_CTX *_mem_save_info_0;
22254         TALLOC_CTX *_mem_save_needed_0;
22255         TALLOC_CTX *_mem_save_count_0;
22256         if (flags & NDR_IN) {
22257                 ZERO_STRUCT(r->out);
22258
22259                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22260                 if (_ptr_servername) {
22261                         NDR_PULL_ALLOC(ndr, r->in.servername);
22262                 } else {
22263                         r->in.servername = NULL;
22264                 }
22265                 if (r->in.servername) {
22266                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22267                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22268                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22269                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22270                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22271                                 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));
22272                         }
22273                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22274                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22276                 }
22277                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22278                 if (_ptr_environment) {
22279                         NDR_PULL_ALLOC(ndr, r->in.environment);
22280                 } else {
22281                         r->in.environment = NULL;
22282                 }
22283                 if (r->in.environment) {
22284                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22285                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22286                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22287                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22288                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22289                                 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));
22290                         }
22291                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22292                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22293                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22294                 }
22295                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22296                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22297                 if (_ptr_buffer) {
22298                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22299                 } else {
22300                         r->in.buffer = NULL;
22301                 }
22302                 if (r->in.buffer) {
22303                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22304                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22305                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22306                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22307                 }
22308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22309                 NDR_PULL_ALLOC(ndr, r->out.needed);
22310                 ZERO_STRUCTP(r->out.needed);
22311                 NDR_PULL_ALLOC(ndr, r->out.count);
22312                 ZERO_STRUCTP(r->out.count);
22313         }
22314         if (flags & NDR_OUT) {
22315                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22316                 if (_ptr_info) {
22317                         NDR_PULL_ALLOC(ndr, r->out.info);
22318                 } else {
22319                         r->out.info = NULL;
22320                 }
22321                 if (r->out.info) {
22322                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22323                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22324                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22325                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22326                 }
22327                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22328                         NDR_PULL_ALLOC(ndr, r->out.needed);
22329                 }
22330                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22331                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22333                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22334                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22335                         NDR_PULL_ALLOC(ndr, r->out.count);
22336                 }
22337                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22338                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22340                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22341                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22342         }
22343         return NDR_ERR_SUCCESS;
22344 }
22345
22346 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
22347 {
22348         uint32_t cntr_info_0;
22349         if (flags & NDR_IN) {
22350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22352         }
22353         if (flags & NDR_OUT) {
22354                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22355                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22356                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22357                 }
22358                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22359                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22360                 }
22361         }
22362         return NDR_ERR_SUCCESS;
22363 }
22364
22365 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
22366 {
22367         uint32_t cntr_info_0;
22368         TALLOC_CTX *_mem_save_info_0;
22369         if (flags & NDR_IN) {
22370                 ZERO_STRUCT(r->out);
22371
22372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22374         }
22375         if (flags & NDR_OUT) {
22376                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22377                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22378                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22379                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22380                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22381                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22382                 }
22383                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22384                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22385                 }
22386                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22387         }
22388         return NDR_ERR_SUCCESS;
22389 }
22390
22391 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
22392 {
22393         uint32_t cntr_info_2;
22394         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
22395         ndr->depth++;
22396         if (flags & NDR_SET_VALUES) {
22397                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22398         }
22399         if (flags & NDR_IN) {
22400                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
22401                 ndr->depth++;
22402                 ndr_print_ptr(ndr, "servername", r->in.servername);
22403                 ndr->depth++;
22404                 if (r->in.servername) {
22405                         ndr_print_string(ndr, "servername", r->in.servername);
22406                 }
22407                 ndr->depth--;
22408                 ndr_print_ptr(ndr, "environment", r->in.environment);
22409                 ndr->depth++;
22410                 if (r->in.environment) {
22411                         ndr_print_string(ndr, "environment", r->in.environment);
22412                 }
22413                 ndr->depth--;
22414                 ndr_print_uint32(ndr, "level", r->in.level);
22415                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22416                 ndr->depth++;
22417                 if (r->in.buffer) {
22418                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22419                 }
22420                 ndr->depth--;
22421                 ndr_print_uint32(ndr, "offered", r->in.offered);
22422                 ndr->depth--;
22423         }
22424         if (flags & NDR_OUT) {
22425                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
22426                 ndr->depth++;
22427                 ndr_print_ptr(ndr, "count", r->out.count);
22428                 ndr->depth++;
22429                 ndr_print_uint32(ndr, "count", *r->out.count);
22430                 ndr->depth--;
22431                 ndr_print_ptr(ndr, "info", r->out.info);
22432                 ndr->depth++;
22433                 ndr_print_ptr(ndr, "info", *r->out.info);
22434                 ndr->depth++;
22435                 if (*r->out.info) {
22436                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22437                         ndr->depth++;
22438                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22439                                 char *idx_2=NULL;
22440                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22441                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22442                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22443                                         free(idx_2);
22444                                 }
22445                         }
22446                         ndr->depth--;
22447                 }
22448                 ndr->depth--;
22449                 ndr->depth--;
22450                 ndr_print_ptr(ndr, "needed", r->out.needed);
22451                 ndr->depth++;
22452                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22453                 ndr->depth--;
22454                 ndr_print_WERROR(ndr, "result", r->out.result);
22455                 ndr->depth--;
22456         }
22457         ndr->depth--;
22458 }
22459
22460 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
22461 {
22462         if (flags & NDR_IN) {
22463                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22464                 if (r->in.server) {
22465                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22466                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22467                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22468                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22469                 }
22470                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22471                 if (r->in.environment) {
22472                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22473                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22474                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22475                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22476                 }
22477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22478                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22479                 if (r->in.buffer) {
22480                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22481                 }
22482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22483         }
22484         if (flags & NDR_OUT) {
22485                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22486                 if (r->out.info) {
22487                         {
22488                                 struct ndr_push *_ndr_info;
22489                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22490                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22491                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22492                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22493                         }
22494                 }
22495                 if (r->out.needed == NULL) {
22496                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22497                 }
22498                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22499                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22500         }
22501         return NDR_ERR_SUCCESS;
22502 }
22503
22504 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
22505 {
22506         uint32_t _ptr_server;
22507         uint32_t _ptr_environment;
22508         uint32_t _ptr_buffer;
22509         uint32_t _ptr_info;
22510         TALLOC_CTX *_mem_save_server_0;
22511         TALLOC_CTX *_mem_save_environment_0;
22512         TALLOC_CTX *_mem_save_buffer_0;
22513         TALLOC_CTX *_mem_save_info_0;
22514         TALLOC_CTX *_mem_save_needed_0;
22515         if (flags & NDR_IN) {
22516                 ZERO_STRUCT(r->out);
22517
22518                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22519                 if (_ptr_server) {
22520                         NDR_PULL_ALLOC(ndr, r->in.server);
22521                 } else {
22522                         r->in.server = NULL;
22523                 }
22524                 if (r->in.server) {
22525                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22526                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22527                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22528                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22529                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22530                                 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));
22531                         }
22532                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22533                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22534                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22535                 }
22536                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22537                 if (_ptr_environment) {
22538                         NDR_PULL_ALLOC(ndr, r->in.environment);
22539                 } else {
22540                         r->in.environment = NULL;
22541                 }
22542                 if (r->in.environment) {
22543                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22544                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22545                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22546                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22547                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22548                                 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));
22549                         }
22550                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22551                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22552                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22553                 }
22554                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22555                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22556                 if (_ptr_buffer) {
22557                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22558                 } else {
22559                         r->in.buffer = NULL;
22560                 }
22561                 if (r->in.buffer) {
22562                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22563                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22564                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22565                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22566                 }
22567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22568                 NDR_PULL_ALLOC(ndr, r->out.needed);
22569                 ZERO_STRUCTP(r->out.needed);
22570         }
22571         if (flags & NDR_OUT) {
22572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22573                 if (_ptr_info) {
22574                         NDR_PULL_ALLOC(ndr, r->out.info);
22575                 } else {
22576                         r->out.info = NULL;
22577                 }
22578                 if (r->out.info) {
22579                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22580                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22581                         {
22582                                 struct ndr_pull *_ndr_info;
22583                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22584                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22585                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22586                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22587                         }
22588                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22589                 }
22590                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22591                         NDR_PULL_ALLOC(ndr, r->out.needed);
22592                 }
22593                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22594                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22595                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22596                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22597                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22598         }
22599         return NDR_ERR_SUCCESS;
22600 }
22601
22602 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
22603 {
22604         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
22605         ndr->depth++;
22606         if (flags & NDR_SET_VALUES) {
22607                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22608         }
22609         if (flags & NDR_IN) {
22610                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
22611                 ndr->depth++;
22612                 ndr_print_ptr(ndr, "server", r->in.server);
22613                 ndr->depth++;
22614                 if (r->in.server) {
22615                         ndr_print_string(ndr, "server", r->in.server);
22616                 }
22617                 ndr->depth--;
22618                 ndr_print_ptr(ndr, "environment", r->in.environment);
22619                 ndr->depth++;
22620                 if (r->in.environment) {
22621                         ndr_print_string(ndr, "environment", r->in.environment);
22622                 }
22623                 ndr->depth--;
22624                 ndr_print_uint32(ndr, "level", r->in.level);
22625                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22626                 ndr->depth++;
22627                 if (r->in.buffer) {
22628                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22629                 }
22630                 ndr->depth--;
22631                 ndr_print_uint32(ndr, "offered", r->in.offered);
22632                 ndr->depth--;
22633         }
22634         if (flags & NDR_OUT) {
22635                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
22636                 ndr->depth++;
22637                 ndr_print_ptr(ndr, "info", r->out.info);
22638                 ndr->depth++;
22639                 if (r->out.info) {
22640                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22641                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
22642                 }
22643                 ndr->depth--;
22644                 ndr_print_ptr(ndr, "needed", r->out.needed);
22645                 ndr->depth++;
22646                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22647                 ndr->depth--;
22648                 ndr_print_WERROR(ndr, "result", r->out.result);
22649                 ndr->depth--;
22650         }
22651         ndr->depth--;
22652 }
22653
22654 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
22655 {
22656         if (flags & NDR_IN) {
22657                 if (r->in.handle == NULL) {
22658                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22659                 }
22660                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22662                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22663                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22664         }
22665         if (flags & NDR_OUT) {
22666                 if (r->out.job_id == NULL) {
22667                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22668                 }
22669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
22670                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22671         }
22672         return NDR_ERR_SUCCESS;
22673 }
22674
22675 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
22676 {
22677         TALLOC_CTX *_mem_save_handle_0;
22678         TALLOC_CTX *_mem_save_job_id_0;
22679         if (flags & NDR_IN) {
22680                 ZERO_STRUCT(r->out);
22681
22682                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22683                         NDR_PULL_ALLOC(ndr, r->in.handle);
22684                 }
22685                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22686                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22687                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22688                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22689                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22690                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22691                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22692                 NDR_PULL_ALLOC(ndr, r->out.job_id);
22693                 ZERO_STRUCTP(r->out.job_id);
22694         }
22695         if (flags & NDR_OUT) {
22696                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22697                         NDR_PULL_ALLOC(ndr, r->out.job_id);
22698                 }
22699                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
22700                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
22701                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
22702                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
22703                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22704         }
22705         return NDR_ERR_SUCCESS;
22706 }
22707
22708 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
22709 {
22710         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
22711         ndr->depth++;
22712         if (flags & NDR_SET_VALUES) {
22713                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22714         }
22715         if (flags & NDR_IN) {
22716                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
22717                 ndr->depth++;
22718                 ndr_print_ptr(ndr, "handle", r->in.handle);
22719                 ndr->depth++;
22720                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22721                 ndr->depth--;
22722                 ndr_print_uint32(ndr, "level", r->in.level);
22723                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22724                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
22725                 ndr->depth--;
22726         }
22727         if (flags & NDR_OUT) {
22728                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
22729                 ndr->depth++;
22730                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
22731                 ndr->depth++;
22732                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
22733                 ndr->depth--;
22734                 ndr_print_WERROR(ndr, "result", r->out.result);
22735                 ndr->depth--;
22736         }
22737         ndr->depth--;
22738 }
22739
22740 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
22741 {
22742         if (flags & NDR_IN) {
22743                 if (r->in.handle == NULL) {
22744                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22745                 }
22746                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22747         }
22748         if (flags & NDR_OUT) {
22749                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22750         }
22751         return NDR_ERR_SUCCESS;
22752 }
22753
22754 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
22755 {
22756         TALLOC_CTX *_mem_save_handle_0;
22757         if (flags & NDR_IN) {
22758                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22759                         NDR_PULL_ALLOC(ndr, r->in.handle);
22760                 }
22761                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22762                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22763                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22764                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22765         }
22766         if (flags & NDR_OUT) {
22767                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22768         }
22769         return NDR_ERR_SUCCESS;
22770 }
22771
22772 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
22773 {
22774         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
22775         ndr->depth++;
22776         if (flags & NDR_SET_VALUES) {
22777                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22778         }
22779         if (flags & NDR_IN) {
22780                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
22781                 ndr->depth++;
22782                 ndr_print_ptr(ndr, "handle", r->in.handle);
22783                 ndr->depth++;
22784                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22785                 ndr->depth--;
22786                 ndr->depth--;
22787         }
22788         if (flags & NDR_OUT) {
22789                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
22790                 ndr->depth++;
22791                 ndr_print_WERROR(ndr, "result", r->out.result);
22792                 ndr->depth--;
22793         }
22794         ndr->depth--;
22795 }
22796
22797 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
22798 {
22799         if (flags & NDR_IN) {
22800                 if (r->in.handle == NULL) {
22801                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22802                 }
22803                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22804                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
22805                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
22806         }
22807         if (flags & NDR_OUT) {
22808                 if (r->out.num_written == NULL) {
22809                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22810                 }
22811                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
22812                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22813         }
22814         return NDR_ERR_SUCCESS;
22815 }
22816
22817 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
22818 {
22819         TALLOC_CTX *_mem_save_handle_0;
22820         TALLOC_CTX *_mem_save_num_written_0;
22821         if (flags & NDR_IN) {
22822                 ZERO_STRUCT(r->out);
22823
22824                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22825                         NDR_PULL_ALLOC(ndr, r->in.handle);
22826                 }
22827                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22828                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22829                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22830                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22831                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
22832                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
22833                 NDR_PULL_ALLOC(ndr, r->out.num_written);
22834                 ZERO_STRUCTP(r->out.num_written);
22835         }
22836         if (flags & NDR_OUT) {
22837                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22838                         NDR_PULL_ALLOC(ndr, r->out.num_written);
22839                 }
22840                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
22841                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
22842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
22843                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
22844                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22845         }
22846         return NDR_ERR_SUCCESS;
22847 }
22848
22849 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
22850 {
22851         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
22852         ndr->depth++;
22853         if (flags & NDR_SET_VALUES) {
22854                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22855         }
22856         if (flags & NDR_IN) {
22857                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
22858                 ndr->depth++;
22859                 ndr_print_ptr(ndr, "handle", r->in.handle);
22860                 ndr->depth++;
22861                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22862                 ndr->depth--;
22863                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
22864                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
22865                 ndr->depth--;
22866         }
22867         if (flags & NDR_OUT) {
22868                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
22869                 ndr->depth++;
22870                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
22871                 ndr->depth++;
22872                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
22873                 ndr->depth--;
22874                 ndr_print_WERROR(ndr, "result", r->out.result);
22875                 ndr->depth--;
22876         }
22877         ndr->depth--;
22878 }
22879
22880 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
22881 {
22882         if (flags & NDR_IN) {
22883                 if (r->in.handle == NULL) {
22884                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22885                 }
22886                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22887         }
22888         if (flags & NDR_OUT) {
22889                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22890         }
22891         return NDR_ERR_SUCCESS;
22892 }
22893
22894 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
22895 {
22896         TALLOC_CTX *_mem_save_handle_0;
22897         if (flags & NDR_IN) {
22898                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22899                         NDR_PULL_ALLOC(ndr, r->in.handle);
22900                 }
22901                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22902                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22903                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22904                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22905         }
22906         if (flags & NDR_OUT) {
22907                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22908         }
22909         return NDR_ERR_SUCCESS;
22910 }
22911
22912 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
22913 {
22914         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
22915         ndr->depth++;
22916         if (flags & NDR_SET_VALUES) {
22917                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22918         }
22919         if (flags & NDR_IN) {
22920                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
22921                 ndr->depth++;
22922                 ndr_print_ptr(ndr, "handle", r->in.handle);
22923                 ndr->depth++;
22924                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22925                 ndr->depth--;
22926                 ndr->depth--;
22927         }
22928         if (flags & NDR_OUT) {
22929                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
22930                 ndr->depth++;
22931                 ndr_print_WERROR(ndr, "result", r->out.result);
22932                 ndr->depth--;
22933         }
22934         ndr->depth--;
22935 }
22936
22937 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
22938 {
22939         if (flags & NDR_IN) {
22940                 if (r->in.handle == NULL) {
22941                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22942                 }
22943                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22944         }
22945         if (flags & NDR_OUT) {
22946                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22947         }
22948         return NDR_ERR_SUCCESS;
22949 }
22950
22951 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
22952 {
22953         TALLOC_CTX *_mem_save_handle_0;
22954         if (flags & NDR_IN) {
22955                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22956                         NDR_PULL_ALLOC(ndr, r->in.handle);
22957                 }
22958                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22959                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22960                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22961                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22962         }
22963         if (flags & NDR_OUT) {
22964                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22965         }
22966         return NDR_ERR_SUCCESS;
22967 }
22968
22969 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
22970 {
22971         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
22972         ndr->depth++;
22973         if (flags & NDR_SET_VALUES) {
22974                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22975         }
22976         if (flags & NDR_IN) {
22977                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
22978                 ndr->depth++;
22979                 ndr_print_ptr(ndr, "handle", r->in.handle);
22980                 ndr->depth++;
22981                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22982                 ndr->depth--;
22983                 ndr->depth--;
22984         }
22985         if (flags & NDR_OUT) {
22986                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
22987                 ndr->depth++;
22988                 ndr_print_WERROR(ndr, "result", r->out.result);
22989                 ndr->depth--;
22990         }
22991         ndr->depth--;
22992 }
22993
22994 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
22995 {
22996         if (flags & NDR_IN) {
22997                 if (r->in.handle == NULL) {
22998                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22999                 }
23000                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23001                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
23002         }
23003         if (flags & NDR_OUT) {
23004                 if (r->out.data == NULL) {
23005                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23006                 }
23007                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_size));
23008                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
23009                 if (r->out._data_size == NULL) {
23010                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23011                 }
23012                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
23013                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23014         }
23015         return NDR_ERR_SUCCESS;
23016 }
23017
23018 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
23019 {
23020         TALLOC_CTX *_mem_save_handle_0;
23021         TALLOC_CTX *_mem_save__data_size_0;
23022         if (flags & NDR_IN) {
23023                 ZERO_STRUCT(r->out);
23024
23025                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23026                         NDR_PULL_ALLOC(ndr, r->in.handle);
23027                 }
23028                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23029                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23030                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23031                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23032                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
23033                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
23034                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
23035                 NDR_PULL_ALLOC(ndr, r->out._data_size);
23036                 ZERO_STRUCTP(r->out._data_size);
23037         }
23038         if (flags & NDR_OUT) {
23039                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
23040                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23041                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
23042                 }
23043                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
23044                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23045                         NDR_PULL_ALLOC(ndr, r->out._data_size);
23046                 }
23047                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
23048                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
23049                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
23050                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
23051                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23052                 if (r->out.data) {
23053                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
23054                 }
23055         }
23056         return NDR_ERR_SUCCESS;
23057 }
23058
23059 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
23060 {
23061         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
23062         ndr->depth++;
23063         if (flags & NDR_SET_VALUES) {
23064                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23065         }
23066         if (flags & NDR_IN) {
23067                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
23068                 ndr->depth++;
23069                 ndr_print_ptr(ndr, "handle", r->in.handle);
23070                 ndr->depth++;
23071                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23072                 ndr->depth--;
23073                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
23074                 ndr->depth--;
23075         }
23076         if (flags & NDR_OUT) {
23077                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
23078                 ndr->depth++;
23079                 ndr_print_ptr(ndr, "data", r->out.data);
23080                 ndr->depth++;
23081                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
23082                 ndr->depth--;
23083                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
23084                 ndr->depth++;
23085                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
23086                 ndr->depth--;
23087                 ndr_print_WERROR(ndr, "result", r->out.result);
23088                 ndr->depth--;
23089         }
23090         ndr->depth--;
23091 }
23092
23093 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
23094 {
23095         if (flags & NDR_IN) {
23096                 if (r->in.handle == NULL) {
23097                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23098                 }
23099                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23100         }
23101         if (flags & NDR_OUT) {
23102                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23103         }
23104         return NDR_ERR_SUCCESS;
23105 }
23106
23107 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
23108 {
23109         TALLOC_CTX *_mem_save_handle_0;
23110         if (flags & NDR_IN) {
23111                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23112                         NDR_PULL_ALLOC(ndr, r->in.handle);
23113                 }
23114                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23115                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23116                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23117                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23118         }
23119         if (flags & NDR_OUT) {
23120                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23121         }
23122         return NDR_ERR_SUCCESS;
23123 }
23124
23125 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
23126 {
23127         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
23128         ndr->depth++;
23129         if (flags & NDR_SET_VALUES) {
23130                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23131         }
23132         if (flags & NDR_IN) {
23133                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
23134                 ndr->depth++;
23135                 ndr_print_ptr(ndr, "handle", r->in.handle);
23136                 ndr->depth++;
23137                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23138                 ndr->depth--;
23139                 ndr->depth--;
23140         }
23141         if (flags & NDR_OUT) {
23142                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
23143                 ndr->depth++;
23144                 ndr_print_WERROR(ndr, "result", r->out.result);
23145                 ndr->depth--;
23146         }
23147         ndr->depth--;
23148 }
23149
23150 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
23151 {
23152         if (flags & NDR_IN) {
23153                 if (r->in.handle == NULL) {
23154                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23155                 }
23156                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23157                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23158                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23159                 if (r->in.buffer) {
23160                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23161                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
23162                 }
23163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23164         }
23165         if (flags & NDR_OUT) {
23166                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
23167                 if (r->out.buffer) {
23168                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23169                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
23170                 }
23171                 if (r->out.needed == NULL) {
23172                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23173                 }
23174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23175                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23176         }
23177         return NDR_ERR_SUCCESS;
23178 }
23179
23180 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
23181 {
23182         uint32_t _ptr_buffer;
23183         TALLOC_CTX *_mem_save_handle_0;
23184         TALLOC_CTX *_mem_save_buffer_0;
23185         TALLOC_CTX *_mem_save_needed_0;
23186         if (flags & NDR_IN) {
23187                 ZERO_STRUCT(r->out);
23188
23189                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23190                         NDR_PULL_ALLOC(ndr, r->in.handle);
23191                 }
23192                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23193                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23194                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23195                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23196                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23197                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23198                 if (_ptr_buffer) {
23199                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23200                 } else {
23201                         r->in.buffer = NULL;
23202                 }
23203                 if (r->in.buffer) {
23204                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23205                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23206                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
23207                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
23208                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
23209                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23210                 }
23211                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23212                 NDR_PULL_ALLOC(ndr, r->out.needed);
23213                 ZERO_STRUCTP(r->out.needed);
23214                 if (r->in.buffer) {
23215                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
23216                 }
23217         }
23218         if (flags & NDR_OUT) {
23219                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23220                 if (_ptr_buffer) {
23221                         NDR_PULL_ALLOC(ndr, r->out.buffer);
23222                 } else {
23223                         r->out.buffer = NULL;
23224                 }
23225                 if (r->out.buffer) {
23226                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23227                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
23228                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
23229                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
23230                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
23231                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23232                 }
23233                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23234                         NDR_PULL_ALLOC(ndr, r->out.needed);
23235                 }
23236                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23237                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23239                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23240                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23241                 if (r->out.buffer) {
23242                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
23243                 }
23244         }
23245         return NDR_ERR_SUCCESS;
23246 }
23247
23248 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
23249 {
23250         ndr_print_struct(ndr, name, "spoolss_AddJob");
23251         ndr->depth++;
23252         if (flags & NDR_SET_VALUES) {
23253                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23254         }
23255         if (flags & NDR_IN) {
23256                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
23257                 ndr->depth++;
23258                 ndr_print_ptr(ndr, "handle", r->in.handle);
23259                 ndr->depth++;
23260                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23261                 ndr->depth--;
23262                 ndr_print_uint32(ndr, "level", r->in.level);
23263                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23264                 ndr->depth++;
23265                 if (r->in.buffer) {
23266                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
23267                 }
23268                 ndr->depth--;
23269                 ndr_print_uint32(ndr, "offered", r->in.offered);
23270                 ndr->depth--;
23271         }
23272         if (flags & NDR_OUT) {
23273                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
23274                 ndr->depth++;
23275                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
23276                 ndr->depth++;
23277                 if (r->out.buffer) {
23278                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
23279                 }
23280                 ndr->depth--;
23281                 ndr_print_ptr(ndr, "needed", r->out.needed);
23282                 ndr->depth++;
23283                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23284                 ndr->depth--;
23285                 ndr_print_WERROR(ndr, "result", r->out.result);
23286                 ndr->depth--;
23287         }
23288         ndr->depth--;
23289 }
23290
23291 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
23292 {
23293         if (flags & NDR_IN) {
23294                 if (r->in.handle == NULL) {
23295                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23296                 }
23297                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
23299         }
23300         if (flags & NDR_OUT) {
23301                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23302         }
23303         return NDR_ERR_SUCCESS;
23304 }
23305
23306 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
23307 {
23308         TALLOC_CTX *_mem_save_handle_0;
23309         if (flags & NDR_IN) {
23310                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23311                         NDR_PULL_ALLOC(ndr, r->in.handle);
23312                 }
23313                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23314                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23315                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23316                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
23318         }
23319         if (flags & NDR_OUT) {
23320                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23321         }
23322         return NDR_ERR_SUCCESS;
23323 }
23324
23325 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
23326 {
23327         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
23328         ndr->depth++;
23329         if (flags & NDR_SET_VALUES) {
23330                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23331         }
23332         if (flags & NDR_IN) {
23333                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
23334                 ndr->depth++;
23335                 ndr_print_ptr(ndr, "handle", r->in.handle);
23336                 ndr->depth++;
23337                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23338                 ndr->depth--;
23339                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
23340                 ndr->depth--;
23341         }
23342         if (flags & NDR_OUT) {
23343                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
23344                 ndr->depth++;
23345                 ndr_print_WERROR(ndr, "result", r->out.result);
23346                 ndr->depth--;
23347         }
23348         ndr->depth--;
23349 }
23350
23351 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
23352 {
23353         if (flags & NDR_IN) {
23354                 if (r->in.handle == NULL) {
23355                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23356                 }
23357                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23358                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23359                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23360                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23361                 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));
23362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23363         }
23364         if (flags & NDR_OUT) {
23365                 if (r->out.type == NULL) {
23366                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23367                 }
23368                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
23369                 if (r->out.data == NULL) {
23370                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23371                 }
23372                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
23373                 if (r->out.needed == NULL) {
23374                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23375                 }
23376                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23377                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23378         }
23379         return NDR_ERR_SUCCESS;
23380 }
23381
23382 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
23383 {
23384         TALLOC_CTX *_mem_save_handle_0;
23385         TALLOC_CTX *_mem_save_type_0;
23386         TALLOC_CTX *_mem_save_data_0;
23387         TALLOC_CTX *_mem_save_needed_0;
23388         if (flags & NDR_IN) {
23389                 ZERO_STRUCT(r->out);
23390
23391                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23392                         NDR_PULL_ALLOC(ndr, r->in.handle);
23393                 }
23394                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23395                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23396                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23397                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23398                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
23399                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
23400                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
23401                         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));
23402                 }
23403                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
23404                 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));
23405                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23406                 NDR_PULL_ALLOC(ndr, r->out.type);
23407                 ZERO_STRUCTP(r->out.type);
23408                 NDR_PULL_ALLOC(ndr, r->out.data);
23409                 ZERO_STRUCTP(r->out.data);
23410                 NDR_PULL_ALLOC(ndr, r->out.needed);
23411                 ZERO_STRUCTP(r->out.needed);
23412         }
23413         if (flags & NDR_OUT) {
23414                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23415                         NDR_PULL_ALLOC(ndr, r->out.type);
23416                 }
23417                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
23418                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
23419                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
23420                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
23421                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23422                         NDR_PULL_ALLOC(ndr, r->out.data);
23423                 }
23424                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
23425                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
23426                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
23427                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
23428                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23429                         NDR_PULL_ALLOC(ndr, r->out.needed);
23430                 }
23431                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23432                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23434                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23435                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23436         }
23437         return NDR_ERR_SUCCESS;
23438 }
23439
23440 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
23441 {
23442         if (flags & NDR_IN) {
23443                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23444         }
23445         if (flags & NDR_OUT) {
23446                 if (r->out.data == NULL) {
23447                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23448                 }
23449                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
23450                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23451         }
23452         return NDR_ERR_SUCCESS;
23453 }
23454
23455 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
23456 {
23457         TALLOC_CTX *_mem_save_data_0;
23458         if (flags & NDR_IN) {
23459                 ZERO_STRUCT(r->out);
23460
23461                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
23462                 NDR_PULL_ALLOC(ndr, r->out.data);
23463                 ZERO_STRUCTP(r->out.data);
23464         }
23465         if (flags & NDR_OUT) {
23466                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23467                         NDR_PULL_ALLOC(ndr, r->out.data);
23468                 }
23469                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
23470                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
23471                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
23472                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23473                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
23474         }
23475         return NDR_ERR_SUCCESS;
23476 }
23477
23478 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
23479 {
23480         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
23481         ndr->depth++;
23482         if (flags & NDR_SET_VALUES) {
23483                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23484         }
23485         if (flags & NDR_IN) {
23486                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
23487                 ndr->depth++;
23488                 ndr_print_ptr(ndr, "handle", r->in.handle);
23489                 ndr->depth++;
23490                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23491                 ndr->depth--;
23492                 ndr_print_string(ndr, "value_name", r->in.value_name);
23493                 ndr_print_uint32(ndr, "offered", r->in.offered);
23494                 ndr->depth--;
23495         }
23496         if (flags & NDR_OUT) {
23497                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
23498                 ndr->depth++;
23499                 ndr_print_ptr(ndr, "type", r->out.type);
23500                 ndr->depth++;
23501                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
23502                 ndr->depth--;
23503                 ndr_print_ptr(ndr, "data", r->out.data);
23504                 ndr->depth++;
23505                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
23506                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
23507                 ndr->depth--;
23508                 ndr_print_ptr(ndr, "needed", r->out.needed);
23509                 ndr->depth++;
23510                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23511                 ndr->depth--;
23512                 ndr_print_WERROR(ndr, "result", r->out.result);
23513                 ndr->depth--;
23514         }
23515         ndr->depth--;
23516 }
23517
23518 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
23519 {
23520         if (flags & NDR_IN) {
23521                 if (r->in.handle == NULL) {
23522                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23523                 }
23524                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23525                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23526                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23527                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23528                 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));
23529                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23530                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
23531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
23532         }
23533         if (flags & NDR_OUT) {
23534                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23535         }
23536         return NDR_ERR_SUCCESS;
23537 }
23538
23539 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
23540 {
23541         if (flags & NDR_IN) {
23542                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23543         }
23544         if (flags & NDR_OUT) {
23545                 if (r->out.data == NULL) {
23546                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23547                 }
23548                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
23549                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23550         }
23551         return NDR_ERR_SUCCESS;
23552 }
23553
23554 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
23555 {
23556         TALLOC_CTX *_mem_save_handle_0;
23557         if (flags & NDR_IN) {
23558                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23559                         NDR_PULL_ALLOC(ndr, r->in.handle);
23560                 }
23561                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23562                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23563                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23564                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23565                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
23566                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
23567                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
23568                         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));
23569                 }
23570                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
23571                 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));
23572                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
23573                 {
23574                         struct ndr_pull *_ndr_data;
23575                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
23576                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
23577                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
23578                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
23579                 }
23580                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
23581         }
23582         if (flags & NDR_OUT) {
23583                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23584         }
23585         return NDR_ERR_SUCCESS;
23586 }
23587
23588 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
23589 {
23590         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
23591         ndr->depth++;
23592         if (flags & NDR_SET_VALUES) {
23593                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23594         }
23595         if (flags & NDR_IN) {
23596                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
23597                 ndr->depth++;
23598                 ndr_print_ptr(ndr, "handle", r->in.handle);
23599                 ndr->depth++;
23600                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23601                 ndr->depth--;
23602                 ndr_print_string(ndr, "value_name", r->in.value_name);
23603                 ndr_print_winreg_Type(ndr, "type", r->in.type);
23604                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
23605                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
23606                 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);
23607                 ndr->depth--;
23608         }
23609         if (flags & NDR_OUT) {
23610                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
23611                 ndr->depth++;
23612                 ndr_print_WERROR(ndr, "result", r->out.result);
23613                 ndr->depth--;
23614         }
23615         ndr->depth--;
23616 }
23617
23618 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
23619 {
23620         if (flags & NDR_IN) {
23621         }
23622         if (flags & NDR_OUT) {
23623                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23624         }
23625         return NDR_ERR_SUCCESS;
23626 }
23627
23628 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
23629 {
23630         if (flags & NDR_IN) {
23631         }
23632         if (flags & NDR_OUT) {
23633                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23634         }
23635         return NDR_ERR_SUCCESS;
23636 }
23637
23638 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
23639 {
23640         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
23641         ndr->depth++;
23642         if (flags & NDR_SET_VALUES) {
23643                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23644         }
23645         if (flags & NDR_IN) {
23646                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
23647                 ndr->depth++;
23648                 ndr->depth--;
23649         }
23650         if (flags & NDR_OUT) {
23651                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
23652                 ndr->depth++;
23653                 ndr_print_WERROR(ndr, "result", r->out.result);
23654                 ndr->depth--;
23655         }
23656         ndr->depth--;
23657 }
23658
23659 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
23660 {
23661         if (flags & NDR_IN) {
23662                 if (r->in.handle == NULL) {
23663                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23664                 }
23665                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23666         }
23667         if (flags & NDR_OUT) {
23668                 if (r->out.handle == NULL) {
23669                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23670                 }
23671                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23672                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23673         }
23674         return NDR_ERR_SUCCESS;
23675 }
23676
23677 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
23678 {
23679         TALLOC_CTX *_mem_save_handle_0;
23680         if (flags & NDR_IN) {
23681                 ZERO_STRUCT(r->out);
23682
23683                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23684                         NDR_PULL_ALLOC(ndr, r->in.handle);
23685                 }
23686                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23687                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23688                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23689                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23690                 NDR_PULL_ALLOC(ndr, r->out.handle);
23691                 *r->out.handle = *r->in.handle;
23692         }
23693         if (flags & NDR_OUT) {
23694                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23695                         NDR_PULL_ALLOC(ndr, r->out.handle);
23696                 }
23697                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23698                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
23699                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23700                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23701                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23702         }
23703         return NDR_ERR_SUCCESS;
23704 }
23705
23706 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
23707 {
23708         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
23709         ndr->depth++;
23710         if (flags & NDR_SET_VALUES) {
23711                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23712         }
23713         if (flags & NDR_IN) {
23714                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
23715                 ndr->depth++;
23716                 ndr_print_ptr(ndr, "handle", r->in.handle);
23717                 ndr->depth++;
23718                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23719                 ndr->depth--;
23720                 ndr->depth--;
23721         }
23722         if (flags & NDR_OUT) {
23723                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
23724                 ndr->depth++;
23725                 ndr_print_ptr(ndr, "handle", r->out.handle);
23726                 ndr->depth++;
23727                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
23728                 ndr->depth--;
23729                 ndr_print_WERROR(ndr, "result", r->out.result);
23730                 ndr->depth--;
23731         }
23732         ndr->depth--;
23733 }
23734
23735 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
23736 {
23737         if (flags & NDR_IN) {
23738                 if (r->in.handle == NULL) {
23739                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23740                 }
23741                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23742                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23743                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
23744                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23745         }
23746         if (flags & NDR_OUT) {
23747                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23748         }
23749         return NDR_ERR_SUCCESS;
23750 }
23751
23752 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
23753 {
23754         TALLOC_CTX *_mem_save_handle_0;
23755         if (flags & NDR_IN) {
23756                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23757                         NDR_PULL_ALLOC(ndr, r->in.handle);
23758                 }
23759                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23760                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23761                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23762                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23764                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23765                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23766         }
23767         if (flags & NDR_OUT) {
23768                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23769         }
23770         return NDR_ERR_SUCCESS;
23771 }
23772
23773 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
23774 {
23775         ndr_print_struct(ndr, name, "spoolss_AddForm");
23776         ndr->depth++;
23777         if (flags & NDR_SET_VALUES) {
23778                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23779         }
23780         if (flags & NDR_IN) {
23781                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
23782                 ndr->depth++;
23783                 ndr_print_ptr(ndr, "handle", r->in.handle);
23784                 ndr->depth++;
23785                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23786                 ndr->depth--;
23787                 ndr_print_uint32(ndr, "level", r->in.level);
23788                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
23789                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
23790                 ndr->depth--;
23791         }
23792         if (flags & NDR_OUT) {
23793                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
23794                 ndr->depth++;
23795                 ndr_print_WERROR(ndr, "result", r->out.result);
23796                 ndr->depth--;
23797         }
23798         ndr->depth--;
23799 }
23800
23801 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
23802 {
23803         if (flags & NDR_IN) {
23804                 if (r->in.handle == NULL) {
23805                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23806                 }
23807                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23808                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23809                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23810                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23811                 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));
23812         }
23813         if (flags & NDR_OUT) {
23814                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23815         }
23816         return NDR_ERR_SUCCESS;
23817 }
23818
23819 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
23820 {
23821         TALLOC_CTX *_mem_save_handle_0;
23822         if (flags & NDR_IN) {
23823                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23824                         NDR_PULL_ALLOC(ndr, r->in.handle);
23825                 }
23826                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23827                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23828                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23829                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23830                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23831                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23832                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23833                         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));
23834                 }
23835                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23836                 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));
23837         }
23838         if (flags & NDR_OUT) {
23839                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23840         }
23841         return NDR_ERR_SUCCESS;
23842 }
23843
23844 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
23845 {
23846         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
23847         ndr->depth++;
23848         if (flags & NDR_SET_VALUES) {
23849                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23850         }
23851         if (flags & NDR_IN) {
23852                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
23853                 ndr->depth++;
23854                 ndr_print_ptr(ndr, "handle", r->in.handle);
23855                 ndr->depth++;
23856                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23857                 ndr->depth--;
23858                 ndr_print_string(ndr, "form_name", r->in.form_name);
23859                 ndr->depth--;
23860         }
23861         if (flags & NDR_OUT) {
23862                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
23863                 ndr->depth++;
23864                 ndr_print_WERROR(ndr, "result", r->out.result);
23865                 ndr->depth--;
23866         }
23867         ndr->depth--;
23868 }
23869
23870 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
23871 {
23872         if (flags & NDR_IN) {
23873                 if (r->in.handle == NULL) {
23874                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23875                 }
23876                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23877                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23878                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23879                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23880                 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));
23881                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23882                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23883                 if (r->in.buffer) {
23884                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23885                 }
23886                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23887         }
23888         if (flags & NDR_OUT) {
23889                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23890                 if (r->out.info) {
23891                         {
23892                                 struct ndr_push *_ndr_info;
23893                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23894                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
23895                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23896                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23897                         }
23898                 }
23899                 if (r->out.needed == NULL) {
23900                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23901                 }
23902                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23903                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23904         }
23905         return NDR_ERR_SUCCESS;
23906 }
23907
23908 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
23909 {
23910         uint32_t _ptr_buffer;
23911         uint32_t _ptr_info;
23912         TALLOC_CTX *_mem_save_handle_0;
23913         TALLOC_CTX *_mem_save_buffer_0;
23914         TALLOC_CTX *_mem_save_info_0;
23915         TALLOC_CTX *_mem_save_needed_0;
23916         if (flags & NDR_IN) {
23917                 ZERO_STRUCT(r->out);
23918
23919                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23920                         NDR_PULL_ALLOC(ndr, r->in.handle);
23921                 }
23922                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23923                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23924                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23925                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23926                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23927                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23928                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23929                         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));
23930                 }
23931                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23932                 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));
23933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23934                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23935                 if (_ptr_buffer) {
23936                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23937                 } else {
23938                         r->in.buffer = NULL;
23939                 }
23940                 if (r->in.buffer) {
23941                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23942                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23943                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23944                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23945                 }
23946                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23947                 NDR_PULL_ALLOC(ndr, r->out.needed);
23948                 ZERO_STRUCTP(r->out.needed);
23949         }
23950         if (flags & NDR_OUT) {
23951                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23952                 if (_ptr_info) {
23953                         NDR_PULL_ALLOC(ndr, r->out.info);
23954                 } else {
23955                         r->out.info = NULL;
23956                 }
23957                 if (r->out.info) {
23958                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23959                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23960                         {
23961                                 struct ndr_pull *_ndr_info;
23962                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23963                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
23964                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23965                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23966                         }
23967                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23968                 }
23969                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23970                         NDR_PULL_ALLOC(ndr, r->out.needed);
23971                 }
23972                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23973                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23974                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23975                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23976                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23977         }
23978         return NDR_ERR_SUCCESS;
23979 }
23980
23981 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
23982 {
23983         ndr_print_struct(ndr, name, "spoolss_GetForm");
23984         ndr->depth++;
23985         if (flags & NDR_SET_VALUES) {
23986                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23987         }
23988         if (flags & NDR_IN) {
23989                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
23990                 ndr->depth++;
23991                 ndr_print_ptr(ndr, "handle", r->in.handle);
23992                 ndr->depth++;
23993                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23994                 ndr->depth--;
23995                 ndr_print_string(ndr, "form_name", r->in.form_name);
23996                 ndr_print_uint32(ndr, "level", r->in.level);
23997                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23998                 ndr->depth++;
23999                 if (r->in.buffer) {
24000                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24001                 }
24002                 ndr->depth--;
24003                 ndr_print_uint32(ndr, "offered", r->in.offered);
24004                 ndr->depth--;
24005         }
24006         if (flags & NDR_OUT) {
24007                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
24008                 ndr->depth++;
24009                 ndr_print_ptr(ndr, "info", r->out.info);
24010                 ndr->depth++;
24011                 if (r->out.info) {
24012                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24013                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
24014                 }
24015                 ndr->depth--;
24016                 ndr_print_ptr(ndr, "needed", r->out.needed);
24017                 ndr->depth++;
24018                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24019                 ndr->depth--;
24020                 ndr_print_WERROR(ndr, "result", r->out.result);
24021                 ndr->depth--;
24022         }
24023         ndr->depth--;
24024 }
24025
24026 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
24027 {
24028         if (flags & NDR_IN) {
24029                 if (r->in.handle == NULL) {
24030                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24031                 }
24032                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24033                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24034                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24035                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24036                 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));
24037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24038                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
24039                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24040         }
24041         if (flags & NDR_OUT) {
24042                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24043         }
24044         return NDR_ERR_SUCCESS;
24045 }
24046
24047 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
24048 {
24049         TALLOC_CTX *_mem_save_handle_0;
24050         if (flags & NDR_IN) {
24051                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24052                         NDR_PULL_ALLOC(ndr, r->in.handle);
24053                 }
24054                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24055                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24056                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24057                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24058                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24059                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24060                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24061                         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));
24062                 }
24063                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24064                 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));
24065                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24066                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
24067                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24068         }
24069         if (flags & NDR_OUT) {
24070                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24071         }
24072         return NDR_ERR_SUCCESS;
24073 }
24074
24075 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
24076 {
24077         ndr_print_struct(ndr, name, "spoolss_SetForm");
24078         ndr->depth++;
24079         if (flags & NDR_SET_VALUES) {
24080                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24081         }
24082         if (flags & NDR_IN) {
24083                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
24084                 ndr->depth++;
24085                 ndr_print_ptr(ndr, "handle", r->in.handle);
24086                 ndr->depth++;
24087                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24088                 ndr->depth--;
24089                 ndr_print_string(ndr, "form_name", r->in.form_name);
24090                 ndr_print_uint32(ndr, "level", r->in.level);
24091                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
24092                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
24093                 ndr->depth--;
24094         }
24095         if (flags & NDR_OUT) {
24096                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
24097                 ndr->depth++;
24098                 ndr_print_WERROR(ndr, "result", r->out.result);
24099                 ndr->depth--;
24100         }
24101         ndr->depth--;
24102 }
24103
24104 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
24105 {
24106         if (flags & NDR_IN) {
24107                 if (r->in.handle == NULL) {
24108                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24109                 }
24110                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24112                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24113                 if (r->in.buffer) {
24114                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24115                 }
24116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24117         }
24118         if (flags & NDR_OUT) {
24119                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24120                 if (r->out.info) {
24121                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24122                 }
24123                 if (r->out.needed == NULL) {
24124                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24125                 }
24126                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24127                 if (r->out.count == NULL) {
24128                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24129                 }
24130                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24131                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24132         }
24133         return NDR_ERR_SUCCESS;
24134 }
24135
24136 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
24137 {
24138         uint32_t _ptr_buffer;
24139         uint32_t _ptr_info;
24140         TALLOC_CTX *_mem_save_handle_0;
24141         TALLOC_CTX *_mem_save_buffer_0;
24142         TALLOC_CTX *_mem_save_info_0;
24143         TALLOC_CTX *_mem_save_needed_0;
24144         TALLOC_CTX *_mem_save_count_0;
24145         if (flags & NDR_IN) {
24146                 ZERO_STRUCT(r->out);
24147
24148                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24149                         NDR_PULL_ALLOC(ndr, r->in.handle);
24150                 }
24151                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24152                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24153                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24154                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24155                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24156                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24157                 if (_ptr_buffer) {
24158                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24159                 } else {
24160                         r->in.buffer = NULL;
24161                 }
24162                 if (r->in.buffer) {
24163                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24164                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24165                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24166                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24167                 }
24168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24169                 NDR_PULL_ALLOC(ndr, r->out.needed);
24170                 ZERO_STRUCTP(r->out.needed);
24171                 NDR_PULL_ALLOC(ndr, r->out.count);
24172                 ZERO_STRUCTP(r->out.count);
24173         }
24174         if (flags & NDR_OUT) {
24175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24176                 if (_ptr_info) {
24177                         NDR_PULL_ALLOC(ndr, r->out.info);
24178                 } else {
24179                         r->out.info = NULL;
24180                 }
24181                 if (r->out.info) {
24182                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24183                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24184                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24185                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24186                 }
24187                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24188                         NDR_PULL_ALLOC(ndr, r->out.needed);
24189                 }
24190                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24191                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24192                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24193                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24194                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24195                         NDR_PULL_ALLOC(ndr, r->out.count);
24196                 }
24197                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24198                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24199                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24200                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24201                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24202         }
24203         return NDR_ERR_SUCCESS;
24204 }
24205
24206 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
24207 {
24208         uint32_t cntr_info_0;
24209         if (flags & NDR_IN) {
24210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24211                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24212         }
24213         if (flags & NDR_OUT) {
24214                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24215                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24216                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24217                 }
24218                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24219                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24220                 }
24221         }
24222         return NDR_ERR_SUCCESS;
24223 }
24224
24225 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
24226 {
24227         uint32_t cntr_info_0;
24228         TALLOC_CTX *_mem_save_info_0;
24229         if (flags & NDR_IN) {
24230                 ZERO_STRUCT(r->out);
24231
24232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24233                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24234         }
24235         if (flags & NDR_OUT) {
24236                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24237                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24238                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24239                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24240                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24241                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24242                 }
24243                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24244                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24245                 }
24246                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24247         }
24248         return NDR_ERR_SUCCESS;
24249 }
24250
24251 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
24252 {
24253         uint32_t cntr_info_2;
24254         ndr_print_struct(ndr, name, "spoolss_EnumForms");
24255         ndr->depth++;
24256         if (flags & NDR_SET_VALUES) {
24257                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24258         }
24259         if (flags & NDR_IN) {
24260                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
24261                 ndr->depth++;
24262                 ndr_print_ptr(ndr, "handle", r->in.handle);
24263                 ndr->depth++;
24264                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24265                 ndr->depth--;
24266                 ndr_print_uint32(ndr, "level", r->in.level);
24267                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24268                 ndr->depth++;
24269                 if (r->in.buffer) {
24270                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24271                 }
24272                 ndr->depth--;
24273                 ndr_print_uint32(ndr, "offered", r->in.offered);
24274                 ndr->depth--;
24275         }
24276         if (flags & NDR_OUT) {
24277                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
24278                 ndr->depth++;
24279                 ndr_print_ptr(ndr, "count", r->out.count);
24280                 ndr->depth++;
24281                 ndr_print_uint32(ndr, "count", *r->out.count);
24282                 ndr->depth--;
24283                 ndr_print_ptr(ndr, "info", r->out.info);
24284                 ndr->depth++;
24285                 ndr_print_ptr(ndr, "info", *r->out.info);
24286                 ndr->depth++;
24287                 if (*r->out.info) {
24288                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24289                         ndr->depth++;
24290                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24291                                 char *idx_2=NULL;
24292                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24293                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24294                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24295                                         free(idx_2);
24296                                 }
24297                         }
24298                         ndr->depth--;
24299                 }
24300                 ndr->depth--;
24301                 ndr->depth--;
24302                 ndr_print_ptr(ndr, "needed", r->out.needed);
24303                 ndr->depth++;
24304                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24305                 ndr->depth--;
24306                 ndr_print_WERROR(ndr, "result", r->out.result);
24307                 ndr->depth--;
24308         }
24309         ndr->depth--;
24310 }
24311
24312 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
24313 {
24314         if (flags & NDR_IN) {
24315                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24316                 if (r->in.servername) {
24317                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24318                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24319                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24320                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24321                 }
24322                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24323                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24324                 if (r->in.buffer) {
24325                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24326                 }
24327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24328         }
24329         if (flags & NDR_OUT) {
24330                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24331                 if (r->out.info) {
24332                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24333                 }
24334                 if (r->out.needed == NULL) {
24335                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24336                 }
24337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24338                 if (r->out.count == NULL) {
24339                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24340                 }
24341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24342                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24343         }
24344         return NDR_ERR_SUCCESS;
24345 }
24346
24347 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
24348 {
24349         uint32_t _ptr_servername;
24350         uint32_t _ptr_buffer;
24351         uint32_t _ptr_info;
24352         TALLOC_CTX *_mem_save_servername_0;
24353         TALLOC_CTX *_mem_save_buffer_0;
24354         TALLOC_CTX *_mem_save_info_0;
24355         TALLOC_CTX *_mem_save_needed_0;
24356         TALLOC_CTX *_mem_save_count_0;
24357         if (flags & NDR_IN) {
24358                 ZERO_STRUCT(r->out);
24359
24360                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24361                 if (_ptr_servername) {
24362                         NDR_PULL_ALLOC(ndr, r->in.servername);
24363                 } else {
24364                         r->in.servername = NULL;
24365                 }
24366                 if (r->in.servername) {
24367                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24368                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24369                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24370                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24371                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24372                                 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));
24373                         }
24374                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24375                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24376                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24377                 }
24378                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24379                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24380                 if (_ptr_buffer) {
24381                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24382                 } else {
24383                         r->in.buffer = NULL;
24384                 }
24385                 if (r->in.buffer) {
24386                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24387                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24388                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24389                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24390                 }
24391                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24392                 NDR_PULL_ALLOC(ndr, r->out.needed);
24393                 ZERO_STRUCTP(r->out.needed);
24394                 NDR_PULL_ALLOC(ndr, r->out.count);
24395                 ZERO_STRUCTP(r->out.count);
24396         }
24397         if (flags & NDR_OUT) {
24398                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24399                 if (_ptr_info) {
24400                         NDR_PULL_ALLOC(ndr, r->out.info);
24401                 } else {
24402                         r->out.info = NULL;
24403                 }
24404                 if (r->out.info) {
24405                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24406                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24407                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24408                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24409                 }
24410                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24411                         NDR_PULL_ALLOC(ndr, r->out.needed);
24412                 }
24413                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24414                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24416                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24417                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24418                         NDR_PULL_ALLOC(ndr, r->out.count);
24419                 }
24420                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24421                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24423                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24424                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24425         }
24426         return NDR_ERR_SUCCESS;
24427 }
24428
24429 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
24430 {
24431         uint32_t cntr_info_0;
24432         if (flags & NDR_IN) {
24433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24435         }
24436         if (flags & NDR_OUT) {
24437                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24438                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24439                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24440                 }
24441                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24442                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24443                 }
24444         }
24445         return NDR_ERR_SUCCESS;
24446 }
24447
24448 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
24449 {
24450         uint32_t cntr_info_0;
24451         TALLOC_CTX *_mem_save_info_0;
24452         if (flags & NDR_IN) {
24453                 ZERO_STRUCT(r->out);
24454
24455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24457         }
24458         if (flags & NDR_OUT) {
24459                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24460                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24461                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24462                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24463                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24464                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24465                 }
24466                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24467                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24468                 }
24469                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24470         }
24471         return NDR_ERR_SUCCESS;
24472 }
24473
24474 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
24475 {
24476         uint32_t cntr_info_2;
24477         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
24478         ndr->depth++;
24479         if (flags & NDR_SET_VALUES) {
24480                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24481         }
24482         if (flags & NDR_IN) {
24483                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
24484                 ndr->depth++;
24485                 ndr_print_ptr(ndr, "servername", r->in.servername);
24486                 ndr->depth++;
24487                 if (r->in.servername) {
24488                         ndr_print_string(ndr, "servername", r->in.servername);
24489                 }
24490                 ndr->depth--;
24491                 ndr_print_uint32(ndr, "level", r->in.level);
24492                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24493                 ndr->depth++;
24494                 if (r->in.buffer) {
24495                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24496                 }
24497                 ndr->depth--;
24498                 ndr_print_uint32(ndr, "offered", r->in.offered);
24499                 ndr->depth--;
24500         }
24501         if (flags & NDR_OUT) {
24502                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
24503                 ndr->depth++;
24504                 ndr_print_ptr(ndr, "count", r->out.count);
24505                 ndr->depth++;
24506                 ndr_print_uint32(ndr, "count", *r->out.count);
24507                 ndr->depth--;
24508                 ndr_print_ptr(ndr, "info", r->out.info);
24509                 ndr->depth++;
24510                 ndr_print_ptr(ndr, "info", *r->out.info);
24511                 ndr->depth++;
24512                 if (*r->out.info) {
24513                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24514                         ndr->depth++;
24515                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24516                                 char *idx_2=NULL;
24517                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24518                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24519                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24520                                         free(idx_2);
24521                                 }
24522                         }
24523                         ndr->depth--;
24524                 }
24525                 ndr->depth--;
24526                 ndr->depth--;
24527                 ndr_print_ptr(ndr, "needed", r->out.needed);
24528                 ndr->depth++;
24529                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24530                 ndr->depth--;
24531                 ndr_print_WERROR(ndr, "result", r->out.result);
24532                 ndr->depth--;
24533         }
24534         ndr->depth--;
24535 }
24536
24537 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
24538 {
24539         if (flags & NDR_IN) {
24540                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24541                 if (r->in.servername) {
24542                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24543                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24544                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24545                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24546                 }
24547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24548                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24549                 if (r->in.buffer) {
24550                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24551                 }
24552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24553         }
24554         if (flags & NDR_OUT) {
24555                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24556                 if (r->out.info) {
24557                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24558                 }
24559                 if (r->out.needed == NULL) {
24560                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24561                 }
24562                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24563                 if (r->out.count == NULL) {
24564                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24565                 }
24566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24567                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24568         }
24569         return NDR_ERR_SUCCESS;
24570 }
24571
24572 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
24573 {
24574         uint32_t _ptr_servername;
24575         uint32_t _ptr_buffer;
24576         uint32_t _ptr_info;
24577         TALLOC_CTX *_mem_save_servername_0;
24578         TALLOC_CTX *_mem_save_buffer_0;
24579         TALLOC_CTX *_mem_save_info_0;
24580         TALLOC_CTX *_mem_save_needed_0;
24581         TALLOC_CTX *_mem_save_count_0;
24582         if (flags & NDR_IN) {
24583                 ZERO_STRUCT(r->out);
24584
24585                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24586                 if (_ptr_servername) {
24587                         NDR_PULL_ALLOC(ndr, r->in.servername);
24588                 } else {
24589                         r->in.servername = NULL;
24590                 }
24591                 if (r->in.servername) {
24592                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24593                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24594                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24595                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24596                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24597                                 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));
24598                         }
24599                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24600                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24601                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24602                 }
24603                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24604                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24605                 if (_ptr_buffer) {
24606                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24607                 } else {
24608                         r->in.buffer = NULL;
24609                 }
24610                 if (r->in.buffer) {
24611                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24612                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24613                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24615                 }
24616                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24617                 NDR_PULL_ALLOC(ndr, r->out.needed);
24618                 ZERO_STRUCTP(r->out.needed);
24619                 NDR_PULL_ALLOC(ndr, r->out.count);
24620                 ZERO_STRUCTP(r->out.count);
24621         }
24622         if (flags & NDR_OUT) {
24623                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24624                 if (_ptr_info) {
24625                         NDR_PULL_ALLOC(ndr, r->out.info);
24626                 } else {
24627                         r->out.info = NULL;
24628                 }
24629                 if (r->out.info) {
24630                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24631                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24632                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24633                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24634                 }
24635                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24636                         NDR_PULL_ALLOC(ndr, r->out.needed);
24637                 }
24638                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24639                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24640                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24641                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24642                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24643                         NDR_PULL_ALLOC(ndr, r->out.count);
24644                 }
24645                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24646                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24647                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24648                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24649                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24650         }
24651         return NDR_ERR_SUCCESS;
24652 }
24653
24654 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
24655 {
24656         uint32_t cntr_info_0;
24657         if (flags & NDR_IN) {
24658                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24659                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24660         }
24661         if (flags & NDR_OUT) {
24662                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24663                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24664                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24665                 }
24666                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24667                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24668                 }
24669         }
24670         return NDR_ERR_SUCCESS;
24671 }
24672
24673 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
24674 {
24675         uint32_t cntr_info_0;
24676         TALLOC_CTX *_mem_save_info_0;
24677         if (flags & NDR_IN) {
24678                 ZERO_STRUCT(r->out);
24679
24680                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24681                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24682         }
24683         if (flags & NDR_OUT) {
24684                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24685                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24686                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24687                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24688                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24689                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24690                 }
24691                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24692                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24693                 }
24694                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24695         }
24696         return NDR_ERR_SUCCESS;
24697 }
24698
24699 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
24700 {
24701         uint32_t cntr_info_2;
24702         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
24703         ndr->depth++;
24704         if (flags & NDR_SET_VALUES) {
24705                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24706         }
24707         if (flags & NDR_IN) {
24708                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
24709                 ndr->depth++;
24710                 ndr_print_ptr(ndr, "servername", r->in.servername);
24711                 ndr->depth++;
24712                 if (r->in.servername) {
24713                         ndr_print_string(ndr, "servername", r->in.servername);
24714                 }
24715                 ndr->depth--;
24716                 ndr_print_uint32(ndr, "level", r->in.level);
24717                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24718                 ndr->depth++;
24719                 if (r->in.buffer) {
24720                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24721                 }
24722                 ndr->depth--;
24723                 ndr_print_uint32(ndr, "offered", r->in.offered);
24724                 ndr->depth--;
24725         }
24726         if (flags & NDR_OUT) {
24727                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
24728                 ndr->depth++;
24729                 ndr_print_ptr(ndr, "count", r->out.count);
24730                 ndr->depth++;
24731                 ndr_print_uint32(ndr, "count", *r->out.count);
24732                 ndr->depth--;
24733                 ndr_print_ptr(ndr, "info", r->out.info);
24734                 ndr->depth++;
24735                 ndr_print_ptr(ndr, "info", *r->out.info);
24736                 ndr->depth++;
24737                 if (*r->out.info) {
24738                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24739                         ndr->depth++;
24740                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24741                                 char *idx_2=NULL;
24742                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24743                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24744                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24745                                         free(idx_2);
24746                                 }
24747                         }
24748                         ndr->depth--;
24749                 }
24750                 ndr->depth--;
24751                 ndr->depth--;
24752                 ndr_print_ptr(ndr, "needed", r->out.needed);
24753                 ndr->depth++;
24754                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24755                 ndr->depth--;
24756                 ndr_print_WERROR(ndr, "result", r->out.result);
24757                 ndr->depth--;
24758         }
24759         ndr->depth--;
24760 }
24761
24762 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
24763 {
24764         if (flags & NDR_IN) {
24765                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
24766                 if (r->in.server_name) {
24767                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24768                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24769                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24770                         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));
24771                 }
24772                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
24773                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
24774                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24775                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
24776                 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));
24777         }
24778         if (flags & NDR_OUT) {
24779                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24780         }
24781         return NDR_ERR_SUCCESS;
24782 }
24783
24784 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
24785 {
24786         uint32_t _ptr_server_name;
24787         TALLOC_CTX *_mem_save_server_name_0;
24788         if (flags & NDR_IN) {
24789                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
24790                 if (_ptr_server_name) {
24791                         NDR_PULL_ALLOC(ndr, r->in.server_name);
24792                 } else {
24793                         r->in.server_name = NULL;
24794                 }
24795                 if (r->in.server_name) {
24796                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
24797                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
24798                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
24799                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
24800                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
24801                                 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));
24802                         }
24803                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
24804                         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));
24805                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
24806                 }
24807                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
24808                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
24809                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
24810                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
24811                         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));
24812                 }
24813                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
24814                 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));
24815         }
24816         if (flags & NDR_OUT) {
24817                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24818         }
24819         return NDR_ERR_SUCCESS;
24820 }
24821
24822 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
24823 {
24824         ndr_print_struct(ndr, name, "spoolss_AddPort");
24825         ndr->depth++;
24826         if (flags & NDR_SET_VALUES) {
24827                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24828         }
24829         if (flags & NDR_IN) {
24830                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
24831                 ndr->depth++;
24832                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
24833                 ndr->depth++;
24834                 if (r->in.server_name) {
24835                         ndr_print_string(ndr, "server_name", r->in.server_name);
24836                 }
24837                 ndr->depth--;
24838                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
24839                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
24840                 ndr->depth--;
24841         }
24842         if (flags & NDR_OUT) {
24843                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
24844                 ndr->depth++;
24845                 ndr_print_WERROR(ndr, "result", r->out.result);
24846                 ndr->depth--;
24847         }
24848         ndr->depth--;
24849 }
24850
24851 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
24852 {
24853         if (flags & NDR_IN) {
24854         }
24855         if (flags & NDR_OUT) {
24856                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24857         }
24858         return NDR_ERR_SUCCESS;
24859 }
24860
24861 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
24862 {
24863         if (flags & NDR_IN) {
24864         }
24865         if (flags & NDR_OUT) {
24866                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24867         }
24868         return NDR_ERR_SUCCESS;
24869 }
24870
24871 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
24872 {
24873         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
24874         ndr->depth++;
24875         if (flags & NDR_SET_VALUES) {
24876                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24877         }
24878         if (flags & NDR_IN) {
24879                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
24880                 ndr->depth++;
24881                 ndr->depth--;
24882         }
24883         if (flags & NDR_OUT) {
24884                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
24885                 ndr->depth++;
24886                 ndr_print_WERROR(ndr, "result", r->out.result);
24887                 ndr->depth--;
24888         }
24889         ndr->depth--;
24890 }
24891
24892 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
24893 {
24894         if (flags & NDR_IN) {
24895         }
24896         if (flags & NDR_OUT) {
24897                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24898         }
24899         return NDR_ERR_SUCCESS;
24900 }
24901
24902 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
24903 {
24904         if (flags & NDR_IN) {
24905         }
24906         if (flags & NDR_OUT) {
24907                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24908         }
24909         return NDR_ERR_SUCCESS;
24910 }
24911
24912 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
24913 {
24914         ndr_print_struct(ndr, name, "spoolss_DeletePort");
24915         ndr->depth++;
24916         if (flags & NDR_SET_VALUES) {
24917                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24918         }
24919         if (flags & NDR_IN) {
24920                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
24921                 ndr->depth++;
24922                 ndr->depth--;
24923         }
24924         if (flags & NDR_OUT) {
24925                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
24926                 ndr->depth++;
24927                 ndr_print_WERROR(ndr, "result", r->out.result);
24928                 ndr->depth--;
24929         }
24930         ndr->depth--;
24931 }
24932
24933 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
24934 {
24935         if (flags & NDR_IN) {
24936                 if (r->in.handle == NULL) {
24937                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24938                 }
24939                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24940                 if (r->in.devmode_ctr == NULL) {
24941                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24942                 }
24943                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24944         }
24945         if (flags & NDR_OUT) {
24946                 if (r->out.gdi_handle == NULL) {
24947                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24948                 }
24949                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24950                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24951         }
24952         return NDR_ERR_SUCCESS;
24953 }
24954
24955 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
24956 {
24957         TALLOC_CTX *_mem_save_handle_0;
24958         TALLOC_CTX *_mem_save_gdi_handle_0;
24959         TALLOC_CTX *_mem_save_devmode_ctr_0;
24960         if (flags & NDR_IN) {
24961                 ZERO_STRUCT(r->out);
24962
24963                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24964                         NDR_PULL_ALLOC(ndr, r->in.handle);
24965                 }
24966                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24967                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24968                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24969                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24970                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24971                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
24972                 }
24973                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
24974                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
24975                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24976                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
24977                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24978                 ZERO_STRUCTP(r->out.gdi_handle);
24979         }
24980         if (flags & NDR_OUT) {
24981                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24982                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24983                 }
24984                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24985                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
24986                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24987                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
24988                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24989         }
24990         return NDR_ERR_SUCCESS;
24991 }
24992
24993 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
24994 {
24995         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
24996         ndr->depth++;
24997         if (flags & NDR_SET_VALUES) {
24998                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24999         }
25000         if (flags & NDR_IN) {
25001                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
25002                 ndr->depth++;
25003                 ndr_print_ptr(ndr, "handle", r->in.handle);
25004                 ndr->depth++;
25005                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25006                 ndr->depth--;
25007                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25008                 ndr->depth++;
25009                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25010                 ndr->depth--;
25011                 ndr->depth--;
25012         }
25013         if (flags & NDR_OUT) {
25014                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
25015                 ndr->depth++;
25016                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25017                 ndr->depth++;
25018                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25019                 ndr->depth--;
25020                 ndr_print_WERROR(ndr, "result", r->out.result);
25021                 ndr->depth--;
25022         }
25023         ndr->depth--;
25024 }
25025
25026 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
25027 {
25028         if (flags & NDR_IN) {
25029         }
25030         if (flags & NDR_OUT) {
25031                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25032         }
25033         return NDR_ERR_SUCCESS;
25034 }
25035
25036 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
25037 {
25038         if (flags & NDR_IN) {
25039         }
25040         if (flags & NDR_OUT) {
25041                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25042         }
25043         return NDR_ERR_SUCCESS;
25044 }
25045
25046 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
25047 {
25048         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
25049         ndr->depth++;
25050         if (flags & NDR_SET_VALUES) {
25051                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25052         }
25053         if (flags & NDR_IN) {
25054                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
25055                 ndr->depth++;
25056                 ndr->depth--;
25057         }
25058         if (flags & NDR_OUT) {
25059                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
25060                 ndr->depth++;
25061                 ndr_print_WERROR(ndr, "result", r->out.result);
25062                 ndr->depth--;
25063         }
25064         ndr->depth--;
25065 }
25066
25067 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
25068 {
25069         if (flags & NDR_IN) {
25070                 if (r->in.gdi_handle == NULL) {
25071                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25072                 }
25073                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
25074         }
25075         if (flags & NDR_OUT) {
25076                 if (r->out.gdi_handle == NULL) {
25077                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25078                 }
25079                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25080                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25081         }
25082         return NDR_ERR_SUCCESS;
25083 }
25084
25085 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
25086 {
25087         TALLOC_CTX *_mem_save_gdi_handle_0;
25088         if (flags & NDR_IN) {
25089                 ZERO_STRUCT(r->out);
25090
25091                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25092                         NDR_PULL_ALLOC(ndr, r->in.gdi_handle);
25093                 }
25094                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25095                 NDR_PULL_SET_MEM_CTX(ndr, r->in.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25096                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
25097                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25098                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25099                 *r->out.gdi_handle = *r->in.gdi_handle;
25100         }
25101         if (flags & NDR_OUT) {
25102                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25103                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25104                 }
25105                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25106                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25107                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25108                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25109                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25110         }
25111         return NDR_ERR_SUCCESS;
25112 }
25113
25114 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
25115 {
25116         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
25117         ndr->depth++;
25118         if (flags & NDR_SET_VALUES) {
25119                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25120         }
25121         if (flags & NDR_IN) {
25122                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
25123                 ndr->depth++;
25124                 ndr_print_ptr(ndr, "gdi_handle", r->in.gdi_handle);
25125                 ndr->depth++;
25126                 ndr_print_policy_handle(ndr, "gdi_handle", r->in.gdi_handle);
25127                 ndr->depth--;
25128                 ndr->depth--;
25129         }
25130         if (flags & NDR_OUT) {
25131                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
25132                 ndr->depth++;
25133                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25134                 ndr->depth++;
25135                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25136                 ndr->depth--;
25137                 ndr_print_WERROR(ndr, "result", r->out.result);
25138                 ndr->depth--;
25139         }
25140         ndr->depth--;
25141 }
25142
25143 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
25144 {
25145         if (flags & NDR_IN) {
25146         }
25147         if (flags & NDR_OUT) {
25148                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25149         }
25150         return NDR_ERR_SUCCESS;
25151 }
25152
25153 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
25154 {
25155         if (flags & NDR_IN) {
25156         }
25157         if (flags & NDR_OUT) {
25158                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25159         }
25160         return NDR_ERR_SUCCESS;
25161 }
25162
25163 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
25164 {
25165         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
25166         ndr->depth++;
25167         if (flags & NDR_SET_VALUES) {
25168                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25169         }
25170         if (flags & NDR_IN) {
25171                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
25172                 ndr->depth++;
25173                 ndr->depth--;
25174         }
25175         if (flags & NDR_OUT) {
25176                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
25177                 ndr->depth++;
25178                 ndr_print_WERROR(ndr, "result", r->out.result);
25179                 ndr->depth--;
25180         }
25181         ndr->depth--;
25182 }
25183
25184 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
25185 {
25186         if (flags & NDR_IN) {
25187         }
25188         if (flags & NDR_OUT) {
25189                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25190         }
25191         return NDR_ERR_SUCCESS;
25192 }
25193
25194 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
25195 {
25196         if (flags & NDR_IN) {
25197         }
25198         if (flags & NDR_OUT) {
25199                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25200         }
25201         return NDR_ERR_SUCCESS;
25202 }
25203
25204 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
25205 {
25206         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
25207         ndr->depth++;
25208         if (flags & NDR_SET_VALUES) {
25209                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25210         }
25211         if (flags & NDR_IN) {
25212                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
25213                 ndr->depth++;
25214                 ndr->depth--;
25215         }
25216         if (flags & NDR_OUT) {
25217                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
25218                 ndr->depth++;
25219                 ndr_print_WERROR(ndr, "result", r->out.result);
25220                 ndr->depth--;
25221         }
25222         ndr->depth--;
25223 }
25224
25225 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
25226 {
25227         if (flags & NDR_IN) {
25228         }
25229         if (flags & NDR_OUT) {
25230                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25231         }
25232         return NDR_ERR_SUCCESS;
25233 }
25234
25235 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
25236 {
25237         if (flags & NDR_IN) {
25238         }
25239         if (flags & NDR_OUT) {
25240                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25241         }
25242         return NDR_ERR_SUCCESS;
25243 }
25244
25245 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
25246 {
25247         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
25248         ndr->depth++;
25249         if (flags & NDR_SET_VALUES) {
25250                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25251         }
25252         if (flags & NDR_IN) {
25253                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
25254                 ndr->depth++;
25255                 ndr->depth--;
25256         }
25257         if (flags & NDR_OUT) {
25258                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
25259                 ndr->depth++;
25260                 ndr_print_WERROR(ndr, "result", r->out.result);
25261                 ndr->depth--;
25262         }
25263         ndr->depth--;
25264 }
25265
25266 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
25267 {
25268         if (flags & NDR_IN) {
25269         }
25270         if (flags & NDR_OUT) {
25271                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25272         }
25273         return NDR_ERR_SUCCESS;
25274 }
25275
25276 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
25277 {
25278         if (flags & NDR_IN) {
25279         }
25280         if (flags & NDR_OUT) {
25281                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25282         }
25283         return NDR_ERR_SUCCESS;
25284 }
25285
25286 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
25287 {
25288         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
25289         ndr->depth++;
25290         if (flags & NDR_SET_VALUES) {
25291                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25292         }
25293         if (flags & NDR_IN) {
25294                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
25295                 ndr->depth++;
25296                 ndr->depth--;
25297         }
25298         if (flags & NDR_OUT) {
25299                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
25300                 ndr->depth++;
25301                 ndr_print_WERROR(ndr, "result", r->out.result);
25302                 ndr->depth--;
25303         }
25304         ndr->depth--;
25305 }
25306
25307 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
25308 {
25309         if (flags & NDR_IN) {
25310         }
25311         if (flags & NDR_OUT) {
25312                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25313         }
25314         return NDR_ERR_SUCCESS;
25315 }
25316
25317 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
25318 {
25319         if (flags & NDR_IN) {
25320         }
25321         if (flags & NDR_OUT) {
25322                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25323         }
25324         return NDR_ERR_SUCCESS;
25325 }
25326
25327 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
25328 {
25329         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
25330         ndr->depth++;
25331         if (flags & NDR_SET_VALUES) {
25332                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25333         }
25334         if (flags & NDR_IN) {
25335                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
25336                 ndr->depth++;
25337                 ndr->depth--;
25338         }
25339         if (flags & NDR_OUT) {
25340                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
25341                 ndr->depth++;
25342                 ndr_print_WERROR(ndr, "result", r->out.result);
25343                 ndr->depth--;
25344         }
25345         ndr->depth--;
25346 }
25347
25348 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
25349 {
25350         if (flags & NDR_IN) {
25351         }
25352         if (flags & NDR_OUT) {
25353                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25354         }
25355         return NDR_ERR_SUCCESS;
25356 }
25357
25358 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
25359 {
25360         if (flags & NDR_IN) {
25361         }
25362         if (flags & NDR_OUT) {
25363                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25364         }
25365         return NDR_ERR_SUCCESS;
25366 }
25367
25368 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
25369 {
25370         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
25371         ndr->depth++;
25372         if (flags & NDR_SET_VALUES) {
25373                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25374         }
25375         if (flags & NDR_IN) {
25376                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
25377                 ndr->depth++;
25378                 ndr->depth--;
25379         }
25380         if (flags & NDR_OUT) {
25381                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
25382                 ndr->depth++;
25383                 ndr_print_WERROR(ndr, "result", r->out.result);
25384                 ndr->depth--;
25385         }
25386         ndr->depth--;
25387 }
25388
25389 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
25390 {
25391         if (flags & NDR_IN) {
25392         }
25393         if (flags & NDR_OUT) {
25394                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25395         }
25396         return NDR_ERR_SUCCESS;
25397 }
25398
25399 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
25400 {
25401         if (flags & NDR_IN) {
25402         }
25403         if (flags & NDR_OUT) {
25404                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25405         }
25406         return NDR_ERR_SUCCESS;
25407 }
25408
25409 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
25410 {
25411         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
25412         ndr->depth++;
25413         if (flags & NDR_SET_VALUES) {
25414                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25415         }
25416         if (flags & NDR_IN) {
25417                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
25418                 ndr->depth++;
25419                 ndr->depth--;
25420         }
25421         if (flags & NDR_OUT) {
25422                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
25423                 ndr->depth++;
25424                 ndr_print_WERROR(ndr, "result", r->out.result);
25425                 ndr->depth--;
25426         }
25427         ndr->depth--;
25428 }
25429
25430 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
25431 {
25432         if (flags & NDR_IN) {
25433         }
25434         if (flags & NDR_OUT) {
25435                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25436         }
25437         return NDR_ERR_SUCCESS;
25438 }
25439
25440 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
25441 {
25442         if (flags & NDR_IN) {
25443         }
25444         if (flags & NDR_OUT) {
25445                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25446         }
25447         return NDR_ERR_SUCCESS;
25448 }
25449
25450 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
25451 {
25452         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
25453         ndr->depth++;
25454         if (flags & NDR_SET_VALUES) {
25455                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25456         }
25457         if (flags & NDR_IN) {
25458                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
25459                 ndr->depth++;
25460                 ndr->depth--;
25461         }
25462         if (flags & NDR_OUT) {
25463                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
25464                 ndr->depth++;
25465                 ndr_print_WERROR(ndr, "result", r->out.result);
25466                 ndr->depth--;
25467         }
25468         ndr->depth--;
25469 }
25470
25471 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
25472 {
25473         if (flags & NDR_IN) {
25474                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
25475                 if (r->in.servername) {
25476                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25477                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25478                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25479                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25480                 }
25481                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
25482                 if (r->in.print_processor_name) {
25483                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
25484                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25485                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
25486                         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));
25487                 }
25488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25489                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25490                 if (r->in.buffer) {
25491                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25492                 }
25493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25494         }
25495         if (flags & NDR_OUT) {
25496                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25497                 if (r->out.info) {
25498                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
25499                 }
25500                 if (r->out.needed == NULL) {
25501                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25502                 }
25503                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25504                 if (r->out.count == NULL) {
25505                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25506                 }
25507                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
25508                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25509         }
25510         return NDR_ERR_SUCCESS;
25511 }
25512
25513 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
25514 {
25515         uint32_t _ptr_servername;
25516         uint32_t _ptr_print_processor_name;
25517         uint32_t _ptr_buffer;
25518         uint32_t _ptr_info;
25519         TALLOC_CTX *_mem_save_servername_0;
25520         TALLOC_CTX *_mem_save_print_processor_name_0;
25521         TALLOC_CTX *_mem_save_buffer_0;
25522         TALLOC_CTX *_mem_save_info_0;
25523         TALLOC_CTX *_mem_save_needed_0;
25524         TALLOC_CTX *_mem_save_count_0;
25525         if (flags & NDR_IN) {
25526                 ZERO_STRUCT(r->out);
25527
25528                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
25529                 if (_ptr_servername) {
25530                         NDR_PULL_ALLOC(ndr, r->in.servername);
25531                 } else {
25532                         r->in.servername = NULL;
25533                 }
25534                 if (r->in.servername) {
25535                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25536                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
25537                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
25538                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
25539                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
25540                                 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));
25541                         }
25542                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
25543                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
25544                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
25545                 }
25546                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
25547                 if (_ptr_print_processor_name) {
25548                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
25549                 } else {
25550                         r->in.print_processor_name = NULL;
25551                 }
25552                 if (r->in.print_processor_name) {
25553                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
25554                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
25555                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
25556                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
25557                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
25558                                 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));
25559                         }
25560                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
25561                         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));
25562                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
25563                 }
25564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25565                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25566                 if (_ptr_buffer) {
25567                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25568                 } else {
25569                         r->in.buffer = NULL;
25570                 }
25571                 if (r->in.buffer) {
25572                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25573                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25574                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25575                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25576                 }
25577                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25578                 NDR_PULL_ALLOC(ndr, r->out.needed);
25579                 ZERO_STRUCTP(r->out.needed);
25580                 NDR_PULL_ALLOC(ndr, r->out.count);
25581                 ZERO_STRUCTP(r->out.count);
25582         }
25583         if (flags & NDR_OUT) {
25584                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25585                 if (_ptr_info) {
25586                         NDR_PULL_ALLOC(ndr, r->out.info);
25587                 } else {
25588                         r->out.info = NULL;
25589                 }
25590                 if (r->out.info) {
25591                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25592                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25593                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
25594                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25595                 }
25596                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25597                         NDR_PULL_ALLOC(ndr, r->out.needed);
25598                 }
25599                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25600                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25601                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25602                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25603                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25604                         NDR_PULL_ALLOC(ndr, r->out.count);
25605                 }
25606                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
25607                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
25608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
25609                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
25610                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25611         }
25612         return NDR_ERR_SUCCESS;
25613 }
25614
25615 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
25616 {
25617         uint32_t cntr_info_0;
25618         if (flags & NDR_IN) {
25619                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25620                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
25621         }
25622         if (flags & NDR_OUT) {
25623                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25624                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25625                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25626                 }
25627                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25628                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25629                 }
25630         }
25631         return NDR_ERR_SUCCESS;
25632 }
25633
25634 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
25635 {
25636         uint32_t cntr_info_0;
25637         TALLOC_CTX *_mem_save_info_0;
25638         if (flags & NDR_IN) {
25639                 ZERO_STRUCT(r->out);
25640
25641                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25642                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
25643         }
25644         if (flags & NDR_OUT) {
25645                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
25646                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25647                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25648                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25649                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25650                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25651                 }
25652                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25653                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25654                 }
25655                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25656         }
25657         return NDR_ERR_SUCCESS;
25658 }
25659
25660 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
25661 {
25662         uint32_t cntr_info_2;
25663         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
25664         ndr->depth++;
25665         if (flags & NDR_SET_VALUES) {
25666                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25667         }
25668         if (flags & NDR_IN) {
25669                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
25670                 ndr->depth++;
25671                 ndr_print_ptr(ndr, "servername", r->in.servername);
25672                 ndr->depth++;
25673                 if (r->in.servername) {
25674                         ndr_print_string(ndr, "servername", r->in.servername);
25675                 }
25676                 ndr->depth--;
25677                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
25678                 ndr->depth++;
25679                 if (r->in.print_processor_name) {
25680                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
25681                 }
25682                 ndr->depth--;
25683                 ndr_print_uint32(ndr, "level", r->in.level);
25684                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25685                 ndr->depth++;
25686                 if (r->in.buffer) {
25687                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25688                 }
25689                 ndr->depth--;
25690                 ndr_print_uint32(ndr, "offered", r->in.offered);
25691                 ndr->depth--;
25692         }
25693         if (flags & NDR_OUT) {
25694                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
25695                 ndr->depth++;
25696                 ndr_print_ptr(ndr, "count", r->out.count);
25697                 ndr->depth++;
25698                 ndr_print_uint32(ndr, "count", *r->out.count);
25699                 ndr->depth--;
25700                 ndr_print_ptr(ndr, "info", r->out.info);
25701                 ndr->depth++;
25702                 ndr_print_ptr(ndr, "info", *r->out.info);
25703                 ndr->depth++;
25704                 if (*r->out.info) {
25705                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
25706                         ndr->depth++;
25707                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
25708                                 char *idx_2=NULL;
25709                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
25710                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
25711                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
25712                                         free(idx_2);
25713                                 }
25714                         }
25715                         ndr->depth--;
25716                 }
25717                 ndr->depth--;
25718                 ndr->depth--;
25719                 ndr_print_ptr(ndr, "needed", r->out.needed);
25720                 ndr->depth++;
25721                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25722                 ndr->depth--;
25723                 ndr_print_WERROR(ndr, "result", r->out.result);
25724                 ndr->depth--;
25725         }
25726         ndr->depth--;
25727 }
25728
25729 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
25730 {
25731         if (flags & NDR_IN) {
25732                 if (r->in.handle == NULL) {
25733                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25734                 }
25735                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25736                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
25737                 if (r->in.data_type) {
25738                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
25739                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25740                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
25741                         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));
25742                 }
25743                 if (r->in.devmode_ctr == NULL) {
25744                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25745                 }
25746                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25747         }
25748         if (flags & NDR_OUT) {
25749                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25750         }
25751         return NDR_ERR_SUCCESS;
25752 }
25753
25754 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
25755 {
25756         uint32_t _ptr_data_type;
25757         TALLOC_CTX *_mem_save_handle_0;
25758         TALLOC_CTX *_mem_save_data_type_0;
25759         TALLOC_CTX *_mem_save_devmode_ctr_0;
25760         if (flags & NDR_IN) {
25761                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25762                         NDR_PULL_ALLOC(ndr, r->in.handle);
25763                 }
25764                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25765                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25766                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25767                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25768                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
25769                 if (_ptr_data_type) {
25770                         NDR_PULL_ALLOC(ndr, r->in.data_type);
25771                 } else {
25772                         r->in.data_type = NULL;
25773                 }
25774                 if (r->in.data_type) {
25775                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25776                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
25777                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
25778                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
25779                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
25780                                 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));
25781                         }
25782                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
25783                         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));
25784                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
25785                 }
25786                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25787                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25788                 }
25789                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25790                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25791                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25792                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25793         }
25794         if (flags & NDR_OUT) {
25795                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25796         }
25797         return NDR_ERR_SUCCESS;
25798 }
25799
25800 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
25801 {
25802         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
25803         ndr->depth++;
25804         if (flags & NDR_SET_VALUES) {
25805                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25806         }
25807         if (flags & NDR_IN) {
25808                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
25809                 ndr->depth++;
25810                 ndr_print_ptr(ndr, "handle", r->in.handle);
25811                 ndr->depth++;
25812                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25813                 ndr->depth--;
25814                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
25815                 ndr->depth++;
25816                 if (r->in.data_type) {
25817                         ndr_print_string(ndr, "data_type", r->in.data_type);
25818                 }
25819                 ndr->depth--;
25820                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25821                 ndr->depth++;
25822                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25823                 ndr->depth--;
25824                 ndr->depth--;
25825         }
25826         if (flags & NDR_OUT) {
25827                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
25828                 ndr->depth++;
25829                 ndr_print_WERROR(ndr, "result", r->out.result);
25830                 ndr->depth--;
25831         }
25832         ndr->depth--;
25833 }
25834
25835 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
25836 {
25837         if (flags & NDR_IN) {
25838                 if (r->in.handle == NULL) {
25839                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25840                 }
25841                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25842                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
25843                 if (r->in.architecture) {
25844                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
25845                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25846                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
25847                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25848                 }
25849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25850                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25851                 if (r->in.buffer) {
25852                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25853                 }
25854                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25855                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
25856                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
25857         }
25858         if (flags & NDR_OUT) {
25859                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25860                 if (r->out.info) {
25861                         {
25862                                 struct ndr_push *_ndr_info;
25863                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
25864                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
25865                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
25866                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
25867                         }
25868                 }
25869                 if (r->out.needed == NULL) {
25870                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25871                 }
25872                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25873                 if (r->out.server_major_version == NULL) {
25874                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25875                 }
25876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
25877                 if (r->out.server_minor_version == NULL) {
25878                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25879                 }
25880                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
25881                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25882         }
25883         return NDR_ERR_SUCCESS;
25884 }
25885
25886 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
25887 {
25888         uint32_t _ptr_architecture;
25889         uint32_t _ptr_buffer;
25890         uint32_t _ptr_info;
25891         TALLOC_CTX *_mem_save_handle_0;
25892         TALLOC_CTX *_mem_save_architecture_0;
25893         TALLOC_CTX *_mem_save_buffer_0;
25894         TALLOC_CTX *_mem_save_info_0;
25895         TALLOC_CTX *_mem_save_needed_0;
25896         TALLOC_CTX *_mem_save_server_major_version_0;
25897         TALLOC_CTX *_mem_save_server_minor_version_0;
25898         if (flags & NDR_IN) {
25899                 ZERO_STRUCT(r->out);
25900
25901                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25902                         NDR_PULL_ALLOC(ndr, r->in.handle);
25903                 }
25904                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25905                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25906                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25907                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25908                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
25909                 if (_ptr_architecture) {
25910                         NDR_PULL_ALLOC(ndr, r->in.architecture);
25911                 } else {
25912                         r->in.architecture = NULL;
25913                 }
25914                 if (r->in.architecture) {
25915                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
25916                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
25917                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
25918                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
25919                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
25920                                 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));
25921                         }
25922                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
25923                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
25924                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
25925                 }
25926                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25927                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25928                 if (_ptr_buffer) {
25929                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25930                 } else {
25931                         r->in.buffer = NULL;
25932                 }
25933                 if (r->in.buffer) {
25934                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25935                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25936                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25937                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25938                 }
25939                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25940                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
25941                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
25942                 NDR_PULL_ALLOC(ndr, r->out.needed);
25943                 ZERO_STRUCTP(r->out.needed);
25944                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
25945                 ZERO_STRUCTP(r->out.server_major_version);
25946                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
25947                 ZERO_STRUCTP(r->out.server_minor_version);
25948         }
25949         if (flags & NDR_OUT) {
25950                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25951                 if (_ptr_info) {
25952                         NDR_PULL_ALLOC(ndr, r->out.info);
25953                 } else {
25954                         r->out.info = NULL;
25955                 }
25956                 if (r->out.info) {
25957                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25958                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25959                         {
25960                                 struct ndr_pull *_ndr_info;
25961                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
25962                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
25963                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
25964                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
25965                         }
25966                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25967                 }
25968                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25969                         NDR_PULL_ALLOC(ndr, r->out.needed);
25970                 }
25971                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25972                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25973                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25974                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25975                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25976                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
25977                 }
25978                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
25979                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
25980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
25981                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
25982                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25983                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
25984                 }
25985                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
25986                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
25987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
25988                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
25989                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25990         }
25991         return NDR_ERR_SUCCESS;
25992 }
25993
25994 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
25995 {
25996         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
25997         ndr->depth++;
25998         if (flags & NDR_SET_VALUES) {
25999                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26000         }
26001         if (flags & NDR_IN) {
26002                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
26003                 ndr->depth++;
26004                 ndr_print_ptr(ndr, "handle", r->in.handle);
26005                 ndr->depth++;
26006                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26007                 ndr->depth--;
26008                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
26009                 ndr->depth++;
26010                 if (r->in.architecture) {
26011                         ndr_print_string(ndr, "architecture", r->in.architecture);
26012                 }
26013                 ndr->depth--;
26014                 ndr_print_uint32(ndr, "level", r->in.level);
26015                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26016                 ndr->depth++;
26017                 if (r->in.buffer) {
26018                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
26019                 }
26020                 ndr->depth--;
26021                 ndr_print_uint32(ndr, "offered", r->in.offered);
26022                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
26023                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
26024                 ndr->depth--;
26025         }
26026         if (flags & NDR_OUT) {
26027                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
26028                 ndr->depth++;
26029                 ndr_print_ptr(ndr, "info", r->out.info);
26030                 ndr->depth++;
26031                 if (r->out.info) {
26032                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
26033                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
26034                 }
26035                 ndr->depth--;
26036                 ndr_print_ptr(ndr, "needed", r->out.needed);
26037                 ndr->depth++;
26038                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26039                 ndr->depth--;
26040                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
26041                 ndr->depth++;
26042                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
26043                 ndr->depth--;
26044                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
26045                 ndr->depth++;
26046                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
26047                 ndr->depth--;
26048                 ndr_print_WERROR(ndr, "result", r->out.result);
26049                 ndr->depth--;
26050         }
26051         ndr->depth--;
26052 }
26053
26054 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
26055 {
26056         if (flags & NDR_IN) {
26057         }
26058         if (flags & NDR_OUT) {
26059                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26060         }
26061         return NDR_ERR_SUCCESS;
26062 }
26063
26064 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
26065 {
26066         if (flags & NDR_IN) {
26067         }
26068         if (flags & NDR_OUT) {
26069                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26070         }
26071         return NDR_ERR_SUCCESS;
26072 }
26073
26074 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
26075 {
26076         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
26077         ndr->depth++;
26078         if (flags & NDR_SET_VALUES) {
26079                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26080         }
26081         if (flags & NDR_IN) {
26082                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
26083                 ndr->depth++;
26084                 ndr->depth--;
26085         }
26086         if (flags & NDR_OUT) {
26087                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
26088                 ndr->depth++;
26089                 ndr_print_WERROR(ndr, "result", r->out.result);
26090                 ndr->depth--;
26091         }
26092         ndr->depth--;
26093 }
26094
26095 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26096 {
26097         if (flags & NDR_IN) {
26098         }
26099         if (flags & NDR_OUT) {
26100                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26101         }
26102         return NDR_ERR_SUCCESS;
26103 }
26104
26105 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
26106 {
26107         if (flags & NDR_IN) {
26108         }
26109         if (flags & NDR_OUT) {
26110                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26111         }
26112         return NDR_ERR_SUCCESS;
26113 }
26114
26115 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26116 {
26117         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
26118         ndr->depth++;
26119         if (flags & NDR_SET_VALUES) {
26120                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26121         }
26122         if (flags & NDR_IN) {
26123                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
26124                 ndr->depth++;
26125                 ndr->depth--;
26126         }
26127         if (flags & NDR_OUT) {
26128                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
26129                 ndr->depth++;
26130                 ndr_print_WERROR(ndr, "result", r->out.result);
26131                 ndr->depth--;
26132         }
26133         ndr->depth--;
26134 }
26135
26136 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
26137 {
26138         if (flags & NDR_IN) {
26139                 if (r->in.handle == NULL) {
26140                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26141                 }
26142                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26143         }
26144         if (flags & NDR_OUT) {
26145                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26146         }
26147         return NDR_ERR_SUCCESS;
26148 }
26149
26150 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
26151 {
26152         TALLOC_CTX *_mem_save_handle_0;
26153         if (flags & NDR_IN) {
26154                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26155                         NDR_PULL_ALLOC(ndr, r->in.handle);
26156                 }
26157                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26158                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26159                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26160                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26161         }
26162         if (flags & NDR_OUT) {
26163                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26164         }
26165         return NDR_ERR_SUCCESS;
26166 }
26167
26168 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
26169 {
26170         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
26171         ndr->depth++;
26172         if (flags & NDR_SET_VALUES) {
26173                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26174         }
26175         if (flags & NDR_IN) {
26176                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
26177                 ndr->depth++;
26178                 ndr_print_ptr(ndr, "handle", r->in.handle);
26179                 ndr->depth++;
26180                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26181                 ndr->depth--;
26182                 ndr->depth--;
26183         }
26184         if (flags & NDR_OUT) {
26185                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
26186                 ndr->depth++;
26187                 ndr_print_WERROR(ndr, "result", r->out.result);
26188                 ndr->depth--;
26189         }
26190         ndr->depth--;
26191 }
26192
26193 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26194 {
26195         if (flags & NDR_IN) {
26196         }
26197         if (flags & NDR_OUT) {
26198                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26199         }
26200         return NDR_ERR_SUCCESS;
26201 }
26202
26203 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26204 {
26205         if (flags & NDR_IN) {
26206         }
26207         if (flags & NDR_OUT) {
26208                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26209         }
26210         return NDR_ERR_SUCCESS;
26211 }
26212
26213 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26214 {
26215         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26216         ndr->depth++;
26217         if (flags & NDR_SET_VALUES) {
26218                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26219         }
26220         if (flags & NDR_IN) {
26221                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26222                 ndr->depth++;
26223                 ndr->depth--;
26224         }
26225         if (flags & NDR_OUT) {
26226                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26227                 ndr->depth++;
26228                 ndr_print_WERROR(ndr, "result", r->out.result);
26229                 ndr->depth--;
26230         }
26231         ndr->depth--;
26232 }
26233
26234 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
26235 {
26236         if (flags & NDR_IN) {
26237                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26238                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26239                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26240                 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));
26241                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
26242                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
26243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
26244                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26245                 if (r->in.buffer) {
26246                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
26247                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
26248                 }
26249         }
26250         if (flags & NDR_OUT) {
26251                 if (r->out.handle == NULL) {
26252                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26253                 }
26254                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26255                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26256         }
26257         return NDR_ERR_SUCCESS;
26258 }
26259
26260 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
26261 {
26262         uint32_t _ptr_buffer;
26263         TALLOC_CTX *_mem_save_buffer_0;
26264         TALLOC_CTX *_mem_save_handle_0;
26265         if (flags & NDR_IN) {
26266                 ZERO_STRUCT(r->out);
26267
26268                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
26269                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
26270                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
26271                         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));
26272                 }
26273                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
26274                 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));
26275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
26276                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
26277                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
26278                 if (r->in.bufsize > 512) {
26279                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
26280                 }
26281                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26282                 if (_ptr_buffer) {
26283                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26284                 } else {
26285                         r->in.buffer = NULL;
26286                 }
26287                 if (r->in.buffer) {
26288                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26289                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26290                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26291                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26292                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26293                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26294                 }
26295                 NDR_PULL_ALLOC(ndr, r->out.handle);
26296                 ZERO_STRUCTP(r->out.handle);
26297                 if (r->in.buffer) {
26298                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
26299                 }
26300         }
26301         if (flags & NDR_OUT) {
26302                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26303                         NDR_PULL_ALLOC(ndr, r->out.handle);
26304                 }
26305                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26306                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26307                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26308                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26309                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26310         }
26311         return NDR_ERR_SUCCESS;
26312 }
26313
26314 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
26315 {
26316         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
26317         ndr->depth++;
26318         if (flags & NDR_SET_VALUES) {
26319                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26320         }
26321         if (flags & NDR_IN) {
26322                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
26323                 ndr->depth++;
26324                 ndr_print_string(ndr, "server_name", r->in.server_name);
26325                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
26326                 ndr_print_winreg_Type(ndr, "type", r->in.type);
26327                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
26328                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26329                 ndr->depth++;
26330                 if (r->in.buffer) {
26331                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
26332                 }
26333                 ndr->depth--;
26334                 ndr->depth--;
26335         }
26336         if (flags & NDR_OUT) {
26337                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
26338                 ndr->depth++;
26339                 ndr_print_ptr(ndr, "handle", r->out.handle);
26340                 ndr->depth++;
26341                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26342                 ndr->depth--;
26343                 ndr_print_WERROR(ndr, "result", r->out.result);
26344                 ndr->depth--;
26345         }
26346         ndr->depth--;
26347 }
26348
26349 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
26350 {
26351         if (flags & NDR_IN) {
26352                 if (r->in.handle == NULL) {
26353                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26354                 }
26355                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26356                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
26358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26359                 if (r->in.buffer) {
26360                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
26361                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
26362                 }
26363         }
26364         if (flags & NDR_OUT) {
26365                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26366         }
26367         return NDR_ERR_SUCCESS;
26368 }
26369
26370 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
26371 {
26372         uint32_t _ptr_buffer;
26373         TALLOC_CTX *_mem_save_handle_0;
26374         TALLOC_CTX *_mem_save_buffer_0;
26375         if (flags & NDR_IN) {
26376                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26377                         NDR_PULL_ALLOC(ndr, r->in.handle);
26378                 }
26379                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26380                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26381                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26382                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26383                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26384                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
26385                 if (r->in.bufsize > 512) {
26386                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
26387                 }
26388                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26389                 if (_ptr_buffer) {
26390                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26391                 } else {
26392                         r->in.buffer = NULL;
26393                 }
26394                 if (r->in.buffer) {
26395                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26396                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26397                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26398                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26399                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26400                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26401                 }
26402                 if (r->in.buffer) {
26403                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
26404                 }
26405         }
26406         if (flags & NDR_OUT) {
26407                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26408         }
26409         return NDR_ERR_SUCCESS;
26410 }
26411
26412 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
26413 {
26414         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
26415         ndr->depth++;
26416         if (flags & NDR_SET_VALUES) {
26417                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26418         }
26419         if (flags & NDR_IN) {
26420                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
26421                 ndr->depth++;
26422                 ndr_print_ptr(ndr, "handle", r->in.handle);
26423                 ndr->depth++;
26424                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26425                 ndr->depth--;
26426                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26427                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
26428                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26429                 ndr->depth++;
26430                 if (r->in.buffer) {
26431                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
26432                 }
26433                 ndr->depth--;
26434                 ndr->depth--;
26435         }
26436         if (flags & NDR_OUT) {
26437                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
26438                 ndr->depth++;
26439                 ndr_print_WERROR(ndr, "result", r->out.result);
26440                 ndr->depth--;
26441         }
26442         ndr->depth--;
26443 }
26444
26445 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
26446 {
26447         if (flags & NDR_IN) {
26448                 if (r->in.handle == NULL) {
26449                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26450                 }
26451                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26452         }
26453         if (flags & NDR_OUT) {
26454                 if (r->out.handle == NULL) {
26455                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26456                 }
26457                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26458                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26459         }
26460         return NDR_ERR_SUCCESS;
26461 }
26462
26463 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
26464 {
26465         TALLOC_CTX *_mem_save_handle_0;
26466         if (flags & NDR_IN) {
26467                 ZERO_STRUCT(r->out);
26468
26469                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26470                         NDR_PULL_ALLOC(ndr, r->in.handle);
26471                 }
26472                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26473                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26474                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26475                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26476                 NDR_PULL_ALLOC(ndr, r->out.handle);
26477                 *r->out.handle = *r->in.handle;
26478         }
26479         if (flags & NDR_OUT) {
26480                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26481                         NDR_PULL_ALLOC(ndr, r->out.handle);
26482                 }
26483                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26484                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26485                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26486                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26487                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26488         }
26489         return NDR_ERR_SUCCESS;
26490 }
26491
26492 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
26493 {
26494         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
26495         ndr->depth++;
26496         if (flags & NDR_SET_VALUES) {
26497                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26498         }
26499         if (flags & NDR_IN) {
26500                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
26501                 ndr->depth++;
26502                 ndr_print_ptr(ndr, "handle", r->in.handle);
26503                 ndr->depth++;
26504                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26505                 ndr->depth--;
26506                 ndr->depth--;
26507         }
26508         if (flags & NDR_OUT) {
26509                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
26510                 ndr->depth++;
26511                 ndr_print_ptr(ndr, "handle", r->out.handle);
26512                 ndr->depth++;
26513                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26514                 ndr->depth--;
26515                 ndr_print_WERROR(ndr, "result", r->out.result);
26516                 ndr->depth--;
26517         }
26518         ndr->depth--;
26519 }
26520
26521 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
26522 {
26523         if (flags & NDR_IN) {
26524         }
26525         if (flags & NDR_OUT) {
26526                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26527         }
26528         return NDR_ERR_SUCCESS;
26529 }
26530
26531 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
26532 {
26533         if (flags & NDR_IN) {
26534         }
26535         if (flags & NDR_OUT) {
26536                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26537         }
26538         return NDR_ERR_SUCCESS;
26539 }
26540
26541 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
26542 {
26543         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
26544         ndr->depth++;
26545         if (flags & NDR_SET_VALUES) {
26546                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26547         }
26548         if (flags & NDR_IN) {
26549                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
26550                 ndr->depth++;
26551                 ndr->depth--;
26552         }
26553         if (flags & NDR_OUT) {
26554                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
26555                 ndr->depth++;
26556                 ndr_print_WERROR(ndr, "result", r->out.result);
26557                 ndr->depth--;
26558         }
26559         ndr->depth--;
26560 }
26561
26562 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26563 {
26564         if (flags & NDR_IN) {
26565         }
26566         if (flags & NDR_OUT) {
26567                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26568         }
26569         return NDR_ERR_SUCCESS;
26570 }
26571
26572 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26573 {
26574         if (flags & NDR_IN) {
26575         }
26576         if (flags & NDR_OUT) {
26577                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26578         }
26579         return NDR_ERR_SUCCESS;
26580 }
26581
26582 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26583 {
26584         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
26585         ndr->depth++;
26586         if (flags & NDR_SET_VALUES) {
26587                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26588         }
26589         if (flags & NDR_IN) {
26590                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
26591                 ndr->depth++;
26592                 ndr->depth--;
26593         }
26594         if (flags & NDR_OUT) {
26595                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
26596                 ndr->depth++;
26597                 ndr_print_WERROR(ndr, "result", r->out.result);
26598                 ndr->depth--;
26599         }
26600         ndr->depth--;
26601 }
26602
26603 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
26604 {
26605         if (flags & NDR_IN) {
26606         }
26607         if (flags & NDR_OUT) {
26608                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26609         }
26610         return NDR_ERR_SUCCESS;
26611 }
26612
26613 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
26614 {
26615         if (flags & NDR_IN) {
26616         }
26617         if (flags & NDR_OUT) {
26618                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26619         }
26620         return NDR_ERR_SUCCESS;
26621 }
26622
26623 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
26624 {
26625         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
26626         ndr->depth++;
26627         if (flags & NDR_SET_VALUES) {
26628                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26629         }
26630         if (flags & NDR_IN) {
26631                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
26632                 ndr->depth++;
26633                 ndr->depth--;
26634         }
26635         if (flags & NDR_OUT) {
26636                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
26637                 ndr->depth++;
26638                 ndr_print_WERROR(ndr, "result", r->out.result);
26639                 ndr->depth--;
26640         }
26641         ndr->depth--;
26642 }
26643
26644 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
26645 {
26646         if (flags & NDR_IN) {
26647         }
26648         if (flags & NDR_OUT) {
26649                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26650         }
26651         return NDR_ERR_SUCCESS;
26652 }
26653
26654 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
26655 {
26656         if (flags & NDR_IN) {
26657         }
26658         if (flags & NDR_OUT) {
26659                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26660         }
26661         return NDR_ERR_SUCCESS;
26662 }
26663
26664 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
26665 {
26666         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
26667         ndr->depth++;
26668         if (flags & NDR_SET_VALUES) {
26669                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26670         }
26671         if (flags & NDR_IN) {
26672                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
26673                 ndr->depth++;
26674                 ndr->depth--;
26675         }
26676         if (flags & NDR_OUT) {
26677                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
26678                 ndr->depth++;
26679                 ndr_print_WERROR(ndr, "result", r->out.result);
26680                 ndr->depth--;
26681         }
26682         ndr->depth--;
26683 }
26684
26685 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26686 {
26687         if (flags & NDR_IN) {
26688                 if (r->in.handle == NULL) {
26689                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26690                 }
26691                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26692                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26693                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
26694                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
26695                 if (r->in.local_machine) {
26696                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
26697                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26698                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
26699                         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));
26700                 }
26701                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
26702                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
26703                 if (r->in.notify_options) {
26704                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
26705                 }
26706         }
26707         if (flags & NDR_OUT) {
26708                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26709         }
26710         return NDR_ERR_SUCCESS;
26711 }
26712
26713 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26714 {
26715         uint32_t _ptr_local_machine;
26716         uint32_t _ptr_notify_options;
26717         TALLOC_CTX *_mem_save_handle_0;
26718         TALLOC_CTX *_mem_save_local_machine_0;
26719         TALLOC_CTX *_mem_save_notify_options_0;
26720         if (flags & NDR_IN) {
26721                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26722                         NDR_PULL_ALLOC(ndr, r->in.handle);
26723                 }
26724                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26725                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26726                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26727                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26728                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26729                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
26730                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
26731                 if (_ptr_local_machine) {
26732                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
26733                 } else {
26734                         r->in.local_machine = NULL;
26735                 }
26736                 if (r->in.local_machine) {
26737                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
26738                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
26739                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
26740                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
26741                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
26742                                 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));
26743                         }
26744                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
26745                         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));
26746                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
26747                 }
26748                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
26749                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
26750                 if (_ptr_notify_options) {
26751                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
26752                 } else {
26753                         r->in.notify_options = NULL;
26754                 }
26755                 if (r->in.notify_options) {
26756                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
26757                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
26758                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
26759                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
26760                 }
26761         }
26762         if (flags & NDR_OUT) {
26763                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26764         }
26765         return NDR_ERR_SUCCESS;
26766 }
26767
26768 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26769 {
26770         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26771         ndr->depth++;
26772         if (flags & NDR_SET_VALUES) {
26773                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26774         }
26775         if (flags & NDR_IN) {
26776                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26777                 ndr->depth++;
26778                 ndr_print_ptr(ndr, "handle", r->in.handle);
26779                 ndr->depth++;
26780                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26781                 ndr->depth--;
26782                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26783                 ndr_print_uint32(ndr, "options", r->in.options);
26784                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
26785                 ndr->depth++;
26786                 if (r->in.local_machine) {
26787                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
26788                 }
26789                 ndr->depth--;
26790                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
26791                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
26792                 ndr->depth++;
26793                 if (r->in.notify_options) {
26794                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
26795                 }
26796                 ndr->depth--;
26797                 ndr->depth--;
26798         }
26799         if (flags & NDR_OUT) {
26800                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26801                 ndr->depth++;
26802                 ndr_print_WERROR(ndr, "result", r->out.result);
26803                 ndr->depth--;
26804         }
26805         ndr->depth--;
26806 }
26807
26808 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
26809 {
26810         if (flags & NDR_IN) {
26811                 if (r->in.handle == NULL) {
26812                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26813                 }
26814                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
26816                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26817                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
26818                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
26819                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
26820         }
26821         if (flags & NDR_OUT) {
26822                 if (r->out.reply_result == NULL) {
26823                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26824                 }
26825                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
26826                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26827         }
26828         return NDR_ERR_SUCCESS;
26829 }
26830
26831 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
26832 {
26833         TALLOC_CTX *_mem_save_handle_0;
26834         TALLOC_CTX *_mem_save_reply_result_0;
26835         if (flags & NDR_IN) {
26836                 ZERO_STRUCT(r->out);
26837
26838                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26839                         NDR_PULL_ALLOC(ndr, r->in.handle);
26840                 }
26841                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26842                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26843                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26844                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
26846                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
26848                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
26849                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
26850                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
26851                 ZERO_STRUCTP(r->out.reply_result);
26852         }
26853         if (flags & NDR_OUT) {
26854                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26855                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
26856                 }
26857                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
26858                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
26859                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
26860                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
26861                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26862         }
26863         return NDR_ERR_SUCCESS;
26864 }
26865
26866 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
26867 {
26868         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
26869         ndr->depth++;
26870         if (flags & NDR_SET_VALUES) {
26871                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26872         }
26873         if (flags & NDR_IN) {
26874                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
26875                 ndr->depth++;
26876                 ndr_print_ptr(ndr, "handle", r->in.handle);
26877                 ndr->depth++;
26878                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26879                 ndr->depth--;
26880                 ndr_print_uint32(ndr, "color", r->in.color);
26881                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26882                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
26883                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
26884                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
26885                 ndr->depth--;
26886         }
26887         if (flags & NDR_OUT) {
26888                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
26889                 ndr->depth++;
26890                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
26891                 ndr->depth++;
26892                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
26893                 ndr->depth--;
26894                 ndr_print_WERROR(ndr, "result", r->out.result);
26895                 ndr->depth--;
26896         }
26897         ndr->depth--;
26898 }
26899
26900 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
26901 {
26902         if (flags & NDR_IN) {
26903                 if (r->in.handle == NULL) {
26904                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26905                 }
26906                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
26908                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
26909                 if (r->in.options) {
26910                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
26911                 }
26912         }
26913         if (flags & NDR_OUT) {
26914                 if (r->out.info == NULL) {
26915                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26916                 }
26917                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
26918                 if (*r->out.info) {
26919                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
26920                 }
26921                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26922         }
26923         return NDR_ERR_SUCCESS;
26924 }
26925
26926 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
26927 {
26928         uint32_t _ptr_options;
26929         uint32_t _ptr_info;
26930         TALLOC_CTX *_mem_save_handle_0;
26931         TALLOC_CTX *_mem_save_options_0;
26932         TALLOC_CTX *_mem_save_info_0;
26933         TALLOC_CTX *_mem_save_info_1;
26934         if (flags & NDR_IN) {
26935                 ZERO_STRUCT(r->out);
26936
26937                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26938                         NDR_PULL_ALLOC(ndr, r->in.handle);
26939                 }
26940                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26941                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26942                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26943                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26944                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
26945                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
26946                 if (_ptr_options) {
26947                         NDR_PULL_ALLOC(ndr, r->in.options);
26948                 } else {
26949                         r->in.options = NULL;
26950                 }
26951                 if (r->in.options) {
26952                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
26953                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
26954                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
26955                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
26956                 }
26957                 NDR_PULL_ALLOC(ndr, r->out.info);
26958                 ZERO_STRUCTP(r->out.info);
26959         }
26960         if (flags & NDR_OUT) {
26961                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26962                         NDR_PULL_ALLOC(ndr, r->out.info);
26963                 }
26964                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26965                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
26966                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
26967                 if (_ptr_info) {
26968                         NDR_PULL_ALLOC(ndr, *r->out.info);
26969                 } else {
26970                         *r->out.info = NULL;
26971                 }
26972                 if (*r->out.info) {
26973                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
26974                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
26975                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
26976                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
26977                 }
26978                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
26979                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26980         }
26981         return NDR_ERR_SUCCESS;
26982 }
26983
26984 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
26985 {
26986         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
26987         ndr->depth++;
26988         if (flags & NDR_SET_VALUES) {
26989                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26990         }
26991         if (flags & NDR_IN) {
26992                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
26993                 ndr->depth++;
26994                 ndr_print_ptr(ndr, "handle", r->in.handle);
26995                 ndr->depth++;
26996                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26997                 ndr->depth--;
26998                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
26999                 ndr_print_ptr(ndr, "options", r->in.options);
27000                 ndr->depth++;
27001                 if (r->in.options) {
27002                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
27003                 }
27004                 ndr->depth--;
27005                 ndr->depth--;
27006         }
27007         if (flags & NDR_OUT) {
27008                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
27009                 ndr->depth++;
27010                 ndr_print_ptr(ndr, "info", r->out.info);
27011                 ndr->depth++;
27012                 ndr_print_ptr(ndr, "info", *r->out.info);
27013                 ndr->depth++;
27014                 if (*r->out.info) {
27015                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
27016                 }
27017                 ndr->depth--;
27018                 ndr->depth--;
27019                 ndr_print_WERROR(ndr, "result", r->out.result);
27020                 ndr->depth--;
27021         }
27022         ndr->depth--;
27023 }
27024
27025 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
27026 {
27027         if (flags & NDR_IN) {
27028         }
27029         if (flags & NDR_OUT) {
27030                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27031         }
27032         return NDR_ERR_SUCCESS;
27033 }
27034
27035 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
27036 {
27037         if (flags & NDR_IN) {
27038         }
27039         if (flags & NDR_OUT) {
27040                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27041         }
27042         return NDR_ERR_SUCCESS;
27043 }
27044
27045 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
27046 {
27047         ndr_print_struct(ndr, name, "spoolss_44");
27048         ndr->depth++;
27049         if (flags & NDR_SET_VALUES) {
27050                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27051         }
27052         if (flags & NDR_IN) {
27053                 ndr_print_struct(ndr, "in", "spoolss_44");
27054                 ndr->depth++;
27055                 ndr->depth--;
27056         }
27057         if (flags & NDR_OUT) {
27058                 ndr_print_struct(ndr, "out", "spoolss_44");
27059                 ndr->depth++;
27060                 ndr_print_WERROR(ndr, "result", r->out.result);
27061                 ndr->depth--;
27062         }
27063         ndr->depth--;
27064 }
27065
27066 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
27067 {
27068         if (flags & NDR_IN) {
27069                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
27070                 if (r->in.printername) {
27071                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
27072                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27073                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
27074                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27075                 }
27076                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
27077                 if (r->in.datatype) {
27078                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
27079                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27080                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
27081                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27082                 }
27083                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27084                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
27085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
27086                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27087                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27088         }
27089         if (flags & NDR_OUT) {
27090                 if (r->out.handle == NULL) {
27091                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27092                 }
27093                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27094                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27095         }
27096         return NDR_ERR_SUCCESS;
27097 }
27098
27099 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
27100 {
27101         uint32_t _ptr_printername;
27102         uint32_t _ptr_datatype;
27103         TALLOC_CTX *_mem_save_printername_0;
27104         TALLOC_CTX *_mem_save_datatype_0;
27105         TALLOC_CTX *_mem_save_handle_0;
27106         if (flags & NDR_IN) {
27107                 ZERO_STRUCT(r->out);
27108
27109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
27110                 if (_ptr_printername) {
27111                         NDR_PULL_ALLOC(ndr, r->in.printername);
27112                 } else {
27113                         r->in.printername = NULL;
27114                 }
27115                 if (r->in.printername) {
27116                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
27117                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
27118                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
27119                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
27120                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
27121                                 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));
27122                         }
27123                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
27124                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
27125                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
27126                 }
27127                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
27128                 if (_ptr_datatype) {
27129                         NDR_PULL_ALLOC(ndr, r->in.datatype);
27130                 } else {
27131                         r->in.datatype = NULL;
27132                 }
27133                 if (r->in.datatype) {
27134                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
27135                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
27136                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
27137                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
27138                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
27139                                 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));
27140                         }
27141                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
27142                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
27143                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
27144                 }
27145                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27146                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
27147                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
27148                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27149                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27150                 NDR_PULL_ALLOC(ndr, r->out.handle);
27151                 ZERO_STRUCTP(r->out.handle);
27152         }
27153         if (flags & NDR_OUT) {
27154                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27155                         NDR_PULL_ALLOC(ndr, r->out.handle);
27156                 }
27157                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27158                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27159                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27160                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27161                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27162         }
27163         return NDR_ERR_SUCCESS;
27164 }
27165
27166 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
27167 {
27168         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
27169         ndr->depth++;
27170         if (flags & NDR_SET_VALUES) {
27171                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27172         }
27173         if (flags & NDR_IN) {
27174                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
27175                 ndr->depth++;
27176                 ndr_print_ptr(ndr, "printername", r->in.printername);
27177                 ndr->depth++;
27178                 if (r->in.printername) {
27179                         ndr_print_string(ndr, "printername", r->in.printername);
27180                 }
27181                 ndr->depth--;
27182                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
27183                 ndr->depth++;
27184                 if (r->in.datatype) {
27185                         ndr_print_string(ndr, "datatype", r->in.datatype);
27186                 }
27187                 ndr->depth--;
27188                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
27189                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
27190                 ndr_print_uint32(ndr, "level", r->in.level);
27191                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
27192                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
27193                 ndr->depth--;
27194         }
27195         if (flags & NDR_OUT) {
27196                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
27197                 ndr->depth++;
27198                 ndr_print_ptr(ndr, "handle", r->out.handle);
27199                 ndr->depth++;
27200                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27201                 ndr->depth--;
27202                 ndr_print_WERROR(ndr, "result", r->out.result);
27203                 ndr->depth--;
27204         }
27205         ndr->depth--;
27206 }
27207
27208 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
27209 {
27210         if (flags & NDR_IN) {
27211                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
27212                 if (r->in.server) {
27213                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27214                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27215                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27216                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27217                 }
27218                 if (r->in.info_ctr == NULL) {
27219                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27220                 }
27221                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27222                 if (r->in.devmode_ctr == NULL) {
27223                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27224                 }
27225                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27226                 if (r->in.secdesc_ctr == NULL) {
27227                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27228                 }
27229                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
27230                 if (r->in.userlevel_ctr == NULL) {
27231                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27232                 }
27233                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
27234         }
27235         if (flags & NDR_OUT) {
27236                 if (r->out.handle == NULL) {
27237                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27238                 }
27239                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27240                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27241         }
27242         return NDR_ERR_SUCCESS;
27243 }
27244
27245 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
27246 {
27247         uint32_t _ptr_server;
27248         TALLOC_CTX *_mem_save_server_0;
27249         TALLOC_CTX *_mem_save_info_ctr_0;
27250         TALLOC_CTX *_mem_save_devmode_ctr_0;
27251         TALLOC_CTX *_mem_save_secdesc_ctr_0;
27252         TALLOC_CTX *_mem_save_userlevel_ctr_0;
27253         TALLOC_CTX *_mem_save_handle_0;
27254         if (flags & NDR_IN) {
27255                 ZERO_STRUCT(r->out);
27256
27257                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
27258                 if (_ptr_server) {
27259                         NDR_PULL_ALLOC(ndr, r->in.server);
27260                 } else {
27261                         r->in.server = NULL;
27262                 }
27263                 if (r->in.server) {
27264                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
27265                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
27266                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
27267                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
27268                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
27269                                 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));
27270                         }
27271                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
27272                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
27273                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
27274                 }
27275                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27276                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
27277                 }
27278                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27279                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
27280                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27281                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27282                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27283                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
27284                 }
27285                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27286                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
27287                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27288                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27289                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27290                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
27291                 }
27292                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27293                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
27294                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
27295                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27296                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27297                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
27298                 }
27299                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27300                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
27301                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
27302                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27303                 NDR_PULL_ALLOC(ndr, r->out.handle);
27304                 ZERO_STRUCTP(r->out.handle);
27305         }
27306         if (flags & NDR_OUT) {
27307                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27308                         NDR_PULL_ALLOC(ndr, r->out.handle);
27309                 }
27310                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27311                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27312                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27313                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27314                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27315         }
27316         return NDR_ERR_SUCCESS;
27317 }
27318
27319 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
27320 {
27321         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
27322         ndr->depth++;
27323         if (flags & NDR_SET_VALUES) {
27324                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27325         }
27326         if (flags & NDR_IN) {
27327                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
27328                 ndr->depth++;
27329                 ndr_print_ptr(ndr, "server", r->in.server);
27330                 ndr->depth++;
27331                 if (r->in.server) {
27332                         ndr_print_string(ndr, "server", r->in.server);
27333                 }
27334                 ndr->depth--;
27335                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
27336                 ndr->depth++;
27337                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
27338                 ndr->depth--;
27339                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
27340                 ndr->depth++;
27341                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
27342                 ndr->depth--;
27343                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
27344                 ndr->depth++;
27345                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
27346                 ndr->depth--;
27347                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
27348                 ndr->depth++;
27349                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
27350                 ndr->depth--;
27351                 ndr->depth--;
27352         }
27353         if (flags & NDR_OUT) {
27354                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
27355                 ndr->depth++;
27356                 ndr_print_ptr(ndr, "handle", r->out.handle);
27357                 ndr->depth++;
27358                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27359                 ndr->depth--;
27360                 ndr_print_WERROR(ndr, "result", r->out.result);
27361                 ndr->depth--;
27362         }
27363         ndr->depth--;
27364 }
27365
27366 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
27367 {
27368         if (flags & NDR_IN) {
27369         }
27370         if (flags & NDR_OUT) {
27371                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27372         }
27373         return NDR_ERR_SUCCESS;
27374 }
27375
27376 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
27377 {
27378         if (flags & NDR_IN) {
27379         }
27380         if (flags & NDR_OUT) {
27381                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27382         }
27383         return NDR_ERR_SUCCESS;
27384 }
27385
27386 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
27387 {
27388         ndr_print_struct(ndr, name, "spoolss_47");
27389         ndr->depth++;
27390         if (flags & NDR_SET_VALUES) {
27391                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27392         }
27393         if (flags & NDR_IN) {
27394                 ndr_print_struct(ndr, "in", "spoolss_47");
27395                 ndr->depth++;
27396                 ndr->depth--;
27397         }
27398         if (flags & NDR_OUT) {
27399                 ndr_print_struct(ndr, "out", "spoolss_47");
27400                 ndr->depth++;
27401                 ndr_print_WERROR(ndr, "result", r->out.result);
27402                 ndr->depth--;
27403         }
27404         ndr->depth--;
27405 }
27406
27407 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
27408 {
27409         if (flags & NDR_IN) {
27410                 if (r->in.handle == NULL) {
27411                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27412                 }
27413                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
27415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
27416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
27417         }
27418         if (flags & NDR_OUT) {
27419                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.value_offered / 2));
27420                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
27421                 if (r->out.value_needed == NULL) {
27422                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27423                 }
27424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
27425                 if (r->out.type == NULL) {
27426                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27427                 }
27428                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
27429                 {
27430                         uint32_t _flags_save_uint8 = ndr->flags;
27431                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
27432                         if (r->out.data == NULL) {
27433                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27434                         }
27435                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_offered));
27436                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
27437                         ndr->flags = _flags_save_uint8;
27438                 }
27439                 if (r->out.data_needed == NULL) {
27440                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27441                 }
27442                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
27443                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27444         }
27445         return NDR_ERR_SUCCESS;
27446 }
27447
27448 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
27449 {
27450         TALLOC_CTX *_mem_save_handle_0;
27451         TALLOC_CTX *_mem_save_value_needed_0;
27452         TALLOC_CTX *_mem_save_type_0;
27453         TALLOC_CTX *_mem_save_data_needed_0;
27454         if (flags & NDR_IN) {
27455                 ZERO_STRUCT(r->out);
27456
27457                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27458                         NDR_PULL_ALLOC(ndr, r->in.handle);
27459                 }
27460                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27461                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27462                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27463                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27464                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
27465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
27466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
27467                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
27468                 ZERO_STRUCTP(r->out.value_needed);
27469                 NDR_PULL_ALLOC(ndr, r->out.type);
27470                 ZERO_STRUCTP(r->out.type);
27471                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
27472                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
27473                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
27474                 ZERO_STRUCTP(r->out.data_needed);
27475         }
27476         if (flags & NDR_OUT) {
27477                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
27478                 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));
27479                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27480                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
27481                 }
27482                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27483                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
27484                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
27485                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
27486                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27487                         NDR_PULL_ALLOC(ndr, r->out.type);
27488                 }
27489                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
27490                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
27491                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
27492                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
27493                 {
27494                         uint32_t _flags_save_uint8 = ndr->flags;
27495                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
27496                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
27497                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27498                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
27499                         }
27500                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
27501                         ndr->flags = _flags_save_uint8;
27502                 }
27503                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27504                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
27505                 }
27506                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27507                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
27508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
27509                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
27510                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27511                 if (r->out.value_name) {
27512                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
27513                 }
27514                 if (r->out.data) {
27515                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
27516                 }
27517         }
27518         return NDR_ERR_SUCCESS;
27519 }
27520
27521 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
27522 {
27523         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
27524         ndr->depth++;
27525         if (flags & NDR_SET_VALUES) {
27526                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27527         }
27528         if (flags & NDR_IN) {
27529                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
27530                 ndr->depth++;
27531                 ndr_print_ptr(ndr, "handle", r->in.handle);
27532                 ndr->depth++;
27533                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27534                 ndr->depth--;
27535                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
27536                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
27537                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
27538                 ndr->depth--;
27539         }
27540         if (flags & NDR_OUT) {
27541                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
27542                 ndr->depth++;
27543                 ndr_print_string(ndr, "value_name", r->out.value_name);
27544                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
27545                 ndr->depth++;
27546                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
27547                 ndr->depth--;
27548                 ndr_print_ptr(ndr, "type", r->out.type);
27549                 ndr->depth++;
27550                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
27551                 ndr->depth--;
27552                 ndr_print_ptr(ndr, "data", r->out.data);
27553                 ndr->depth++;
27554                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
27555                 ndr->depth--;
27556                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
27557                 ndr->depth++;
27558                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
27559                 ndr->depth--;
27560                 ndr_print_WERROR(ndr, "result", r->out.result);
27561                 ndr->depth--;
27562         }
27563         ndr->depth--;
27564 }
27565
27566 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
27567 {
27568         if (flags & NDR_IN) {
27569                 if (r->in.handle == NULL) {
27570                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27571                 }
27572                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27573                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27574                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27575                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27576                 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));
27577         }
27578         if (flags & NDR_OUT) {
27579                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27580         }
27581         return NDR_ERR_SUCCESS;
27582 }
27583
27584 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
27585 {
27586         TALLOC_CTX *_mem_save_handle_0;
27587         if (flags & NDR_IN) {
27588                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27589                         NDR_PULL_ALLOC(ndr, r->in.handle);
27590                 }
27591                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27592                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27593                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27594                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27595                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27596                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27597                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27598                         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));
27599                 }
27600                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27601                 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));
27602         }
27603         if (flags & NDR_OUT) {
27604                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27605         }
27606         return NDR_ERR_SUCCESS;
27607 }
27608
27609 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
27610 {
27611         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
27612         ndr->depth++;
27613         if (flags & NDR_SET_VALUES) {
27614                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27615         }
27616         if (flags & NDR_IN) {
27617                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
27618                 ndr->depth++;
27619                 ndr_print_ptr(ndr, "handle", r->in.handle);
27620                 ndr->depth++;
27621                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27622                 ndr->depth--;
27623                 ndr_print_string(ndr, "value_name", r->in.value_name);
27624                 ndr->depth--;
27625         }
27626         if (flags & NDR_OUT) {
27627                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
27628                 ndr->depth++;
27629                 ndr_print_WERROR(ndr, "result", r->out.result);
27630                 ndr->depth--;
27631         }
27632         ndr->depth--;
27633 }
27634
27635 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
27636 {
27637         if (flags & NDR_IN) {
27638         }
27639         if (flags & NDR_OUT) {
27640                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27641         }
27642         return NDR_ERR_SUCCESS;
27643 }
27644
27645 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
27646 {
27647         if (flags & NDR_IN) {
27648         }
27649         if (flags & NDR_OUT) {
27650                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27651         }
27652         return NDR_ERR_SUCCESS;
27653 }
27654
27655 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
27656 {
27657         ndr_print_struct(ndr, name, "spoolss_4a");
27658         ndr->depth++;
27659         if (flags & NDR_SET_VALUES) {
27660                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27661         }
27662         if (flags & NDR_IN) {
27663                 ndr_print_struct(ndr, "in", "spoolss_4a");
27664                 ndr->depth++;
27665                 ndr->depth--;
27666         }
27667         if (flags & NDR_OUT) {
27668                 ndr_print_struct(ndr, "out", "spoolss_4a");
27669                 ndr->depth++;
27670                 ndr_print_WERROR(ndr, "result", r->out.result);
27671                 ndr->depth--;
27672         }
27673         ndr->depth--;
27674 }
27675
27676 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
27677 {
27678         if (flags & NDR_IN) {
27679         }
27680         if (flags & NDR_OUT) {
27681                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27682         }
27683         return NDR_ERR_SUCCESS;
27684 }
27685
27686 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
27687 {
27688         if (flags & NDR_IN) {
27689         }
27690         if (flags & NDR_OUT) {
27691                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27692         }
27693         return NDR_ERR_SUCCESS;
27694 }
27695
27696 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
27697 {
27698         ndr_print_struct(ndr, name, "spoolss_4b");
27699         ndr->depth++;
27700         if (flags & NDR_SET_VALUES) {
27701                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27702         }
27703         if (flags & NDR_IN) {
27704                 ndr_print_struct(ndr, "in", "spoolss_4b");
27705                 ndr->depth++;
27706                 ndr->depth--;
27707         }
27708         if (flags & NDR_OUT) {
27709                 ndr_print_struct(ndr, "out", "spoolss_4b");
27710                 ndr->depth++;
27711                 ndr_print_WERROR(ndr, "result", r->out.result);
27712                 ndr->depth--;
27713         }
27714         ndr->depth--;
27715 }
27716
27717 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
27718 {
27719         if (flags & NDR_IN) {
27720         }
27721         if (flags & NDR_OUT) {
27722                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27723         }
27724         return NDR_ERR_SUCCESS;
27725 }
27726
27727 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
27728 {
27729         if (flags & NDR_IN) {
27730         }
27731         if (flags & NDR_OUT) {
27732                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27733         }
27734         return NDR_ERR_SUCCESS;
27735 }
27736
27737 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
27738 {
27739         ndr_print_struct(ndr, name, "spoolss_4c");
27740         ndr->depth++;
27741         if (flags & NDR_SET_VALUES) {
27742                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27743         }
27744         if (flags & NDR_IN) {
27745                 ndr_print_struct(ndr, "in", "spoolss_4c");
27746                 ndr->depth++;
27747                 ndr->depth--;
27748         }
27749         if (flags & NDR_OUT) {
27750                 ndr_print_struct(ndr, "out", "spoolss_4c");
27751                 ndr->depth++;
27752                 ndr_print_WERROR(ndr, "result", r->out.result);
27753                 ndr->depth--;
27754         }
27755         ndr->depth--;
27756 }
27757
27758 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterDataEx *r)
27759 {
27760         if (flags & NDR_IN) {
27761                 if (r->in.handle == NULL) {
27762                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27763                 }
27764                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27765                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27766                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27767                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27768                 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));
27769                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27770                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27771                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27772                 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));
27773                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
27774                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
27775                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
27776         }
27777         if (flags & NDR_OUT) {
27778                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27779         }
27780         return NDR_ERR_SUCCESS;
27781 }
27782
27783 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterDataEx *r)
27784 {
27785         if (flags & NDR_IN) {
27786                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
27787         }
27788         if (flags & NDR_OUT) {
27789                 if (r->out.data == NULL) {
27790                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27791                 }
27792                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
27793                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
27794         }
27795         return NDR_ERR_SUCCESS;
27796 }
27797
27798 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
27799 {
27800         TALLOC_CTX *_mem_save_handle_0;
27801         if (flags & NDR_IN) {
27802                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27803                         NDR_PULL_ALLOC(ndr, r->in.handle);
27804                 }
27805                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27806                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27807                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27808                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27809                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27810                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27811                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27812                         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));
27813                 }
27814                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27815                 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));
27816                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27817                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27818                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27819                         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));
27820                 }
27821                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27822                 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));
27823                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
27824                 {
27825                         struct ndr_pull *_ndr_data;
27826                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
27827                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
27828                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
27829                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
27830                 }
27831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
27832         }
27833         if (flags & NDR_OUT) {
27834                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27835         }
27836         return NDR_ERR_SUCCESS;
27837 }
27838
27839 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
27840 {
27841         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
27842         ndr->depth++;
27843         if (flags & NDR_SET_VALUES) {
27844                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27845         }
27846         if (flags & NDR_IN) {
27847                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
27848                 ndr->depth++;
27849                 ndr_print_ptr(ndr, "handle", r->in.handle);
27850                 ndr->depth++;
27851                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27852                 ndr->depth--;
27853                 ndr_print_string(ndr, "key_name", r->in.key_name);
27854                 ndr_print_string(ndr, "value_name", r->in.value_name);
27855                 ndr_print_winreg_Type(ndr, "type", r->in.type);
27856                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
27857                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
27858                 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);
27859                 ndr->depth--;
27860         }
27861         if (flags & NDR_OUT) {
27862                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
27863                 ndr->depth++;
27864                 ndr_print_WERROR(ndr, "result", r->out.result);
27865                 ndr->depth--;
27866         }
27867         ndr->depth--;
27868 }
27869
27870 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterDataEx *r)
27871 {
27872         if (flags & NDR_IN) {
27873                 if (r->in.handle == NULL) {
27874                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27875                 }
27876                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27877                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27878                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27879                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27880                 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));
27881                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27882                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27883                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27884                 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));
27885                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27886         }
27887         if (flags & NDR_OUT) {
27888                 if (r->out.type == NULL) {
27889                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27890                 }
27891                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
27892                 if (r->out.data == NULL) {
27893                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27894                 }
27895                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
27896                 if (r->out.needed == NULL) {
27897                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27898                 }
27899                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27900                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27901         }
27902         return NDR_ERR_SUCCESS;
27903 }
27904
27905 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterDataEx *r)
27906 {
27907         TALLOC_CTX *_mem_save_handle_0;
27908         TALLOC_CTX *_mem_save_type_0;
27909         TALLOC_CTX *_mem_save_data_0;
27910         TALLOC_CTX *_mem_save_needed_0;
27911         if (flags & NDR_IN) {
27912                 ZERO_STRUCT(r->out);
27913
27914                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27915                         NDR_PULL_ALLOC(ndr, r->in.handle);
27916                 }
27917                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27918                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27919                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27920                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27921                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27922                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27923                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27924                         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));
27925                 }
27926                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27927                 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));
27928                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27929                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27930                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27931                         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));
27932                 }
27933                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27934                 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));
27935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27936                 NDR_PULL_ALLOC(ndr, r->out.type);
27937                 ZERO_STRUCTP(r->out.type);
27938                 NDR_PULL_ALLOC(ndr, r->out.data);
27939                 ZERO_STRUCTP(r->out.data);
27940                 NDR_PULL_ALLOC(ndr, r->out.needed);
27941                 ZERO_STRUCTP(r->out.needed);
27942         }
27943         if (flags & NDR_OUT) {
27944                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27945                         NDR_PULL_ALLOC(ndr, r->out.type);
27946                 }
27947                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
27948                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
27949                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
27950                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
27951                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27952                         NDR_PULL_ALLOC(ndr, r->out.data);
27953                 }
27954                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
27955                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
27956                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
27957                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
27958                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27959                         NDR_PULL_ALLOC(ndr, r->out.needed);
27960                 }
27961                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27962                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27963                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27964                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27965                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27966         }
27967         return NDR_ERR_SUCCESS;
27968 }
27969
27970 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterDataEx *r)
27971 {
27972         if (flags & NDR_IN) {
27973                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
27974         }
27975         if (flags & NDR_OUT) {
27976                 if (r->out.data == NULL) {
27977                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27978                 }
27979                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
27980                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
27981         }
27982         return NDR_ERR_SUCCESS;
27983 }
27984
27985 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterDataEx *r)
27986 {
27987         TALLOC_CTX *_mem_save_data_0;
27988         if (flags & NDR_IN) {
27989                 ZERO_STRUCT(r->out);
27990
27991                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
27992                 NDR_PULL_ALLOC(ndr, r->out.data);
27993                 ZERO_STRUCTP(r->out.data);
27994         }
27995         if (flags & NDR_OUT) {
27996                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27997                         NDR_PULL_ALLOC(ndr, r->out.data);
27998                 }
27999                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
28000                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
28001                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
28002                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
28003                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
28004         }
28005         return NDR_ERR_SUCCESS;
28006 }
28007
28008 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
28009 {
28010         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
28011         ndr->depth++;
28012         if (flags & NDR_SET_VALUES) {
28013                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28014         }
28015         if (flags & NDR_IN) {
28016                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
28017                 ndr->depth++;
28018                 ndr_print_ptr(ndr, "handle", r->in.handle);
28019                 ndr->depth++;
28020                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28021                 ndr->depth--;
28022                 ndr_print_string(ndr, "key_name", r->in.key_name);
28023                 ndr_print_string(ndr, "value_name", r->in.value_name);
28024                 ndr_print_uint32(ndr, "offered", r->in.offered);
28025                 ndr->depth--;
28026         }
28027         if (flags & NDR_OUT) {
28028                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
28029                 ndr->depth++;
28030                 ndr_print_ptr(ndr, "type", r->out.type);
28031                 ndr->depth++;
28032                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
28033                 ndr->depth--;
28034                 ndr_print_ptr(ndr, "data", r->out.data);
28035                 ndr->depth++;
28036                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
28037                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
28038                 ndr->depth--;
28039                 ndr_print_ptr(ndr, "needed", r->out.needed);
28040                 ndr->depth++;
28041                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28042                 ndr->depth--;
28043                 ndr_print_WERROR(ndr, "result", r->out.result);
28044                 ndr->depth--;
28045         }
28046         ndr->depth--;
28047 }
28048
28049 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
28050 {
28051         if (flags & NDR_IN) {
28052                 if (r->in.handle == NULL) {
28053                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28054                 }
28055                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28056                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28057                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28058                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28059                 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));
28060                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28061         }
28062         if (flags & NDR_OUT) {
28063                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
28064                 if (r->out.needed == NULL) {
28065                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28066                 }
28067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28068                 if (r->out.count == NULL) {
28069                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28070                 }
28071                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
28072                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28073         }
28074         return NDR_ERR_SUCCESS;
28075 }
28076
28077 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
28078 {
28079         TALLOC_CTX *_mem_save_handle_0;
28080         TALLOC_CTX *_mem_save_needed_0;
28081         TALLOC_CTX *_mem_save_count_0;
28082         if (flags & NDR_IN) {
28083                 ZERO_STRUCT(r->out);
28084
28085                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28086                         NDR_PULL_ALLOC(ndr, r->in.handle);
28087                 }
28088                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28089                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28090                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28091                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28092                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28093                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28094                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28095                         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));
28096                 }
28097                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28098                 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));
28099                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28100                 NDR_PULL_ALLOC(ndr, r->out.needed);
28101                 ZERO_STRUCTP(r->out.needed);
28102                 NDR_PULL_ALLOC(ndr, r->out.count);
28103                 ZERO_STRUCTP(r->out.count);
28104         }
28105         if (flags & NDR_OUT) {
28106                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
28107                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28108                         NDR_PULL_ALLOC(ndr, r->out.needed);
28109                 }
28110                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28111                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28112                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28113                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28114                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28115                         NDR_PULL_ALLOC(ndr, r->out.count);
28116                 }
28117                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
28118                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
28119                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
28120                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
28121                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28122         }
28123         return NDR_ERR_SUCCESS;
28124 }
28125
28126 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
28127 {
28128         uint32_t cntr_info_0;
28129         if (flags & NDR_IN) {
28130                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
28131         }
28132         if (flags & NDR_OUT) {
28133                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28134                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28135                 }
28136                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28137                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28138                 }
28139         }
28140         return NDR_ERR_SUCCESS;
28141 }
28142
28143 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
28144 {
28145         uint32_t cntr_info_0;
28146         TALLOC_CTX *_mem_save_info_0;
28147         if (flags & NDR_IN) {
28148                 ZERO_STRUCT(r->out);
28149
28150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
28151         }
28152         if (flags & NDR_OUT) {
28153                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
28154                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
28155                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
28156                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28157                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28158                 }
28159                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28160                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28161                 }
28162                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
28163         }
28164         return NDR_ERR_SUCCESS;
28165 }
28166
28167 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
28168 {
28169         uint32_t cntr_info_2;
28170         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
28171         ndr->depth++;
28172         if (flags & NDR_SET_VALUES) {
28173                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28174         }
28175         if (flags & NDR_IN) {
28176                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
28177                 ndr->depth++;
28178                 ndr_print_ptr(ndr, "handle", r->in.handle);
28179                 ndr->depth++;
28180                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28181                 ndr->depth--;
28182                 ndr_print_string(ndr, "key_name", r->in.key_name);
28183                 ndr_print_uint32(ndr, "offered", r->in.offered);
28184                 ndr->depth--;
28185         }
28186         if (flags & NDR_OUT) {
28187                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
28188                 ndr->depth++;
28189                 ndr_print_ptr(ndr, "count", r->out.count);
28190                 ndr->depth++;
28191                 ndr_print_uint32(ndr, "count", *r->out.count);
28192                 ndr->depth--;
28193                 ndr_print_ptr(ndr, "info", r->out.info);
28194                 ndr->depth++;
28195                 ndr_print_ptr(ndr, "info", *r->out.info);
28196                 ndr->depth++;
28197                 if (*r->out.info) {
28198                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
28199                         ndr->depth++;
28200                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
28201                                 char *idx_2=NULL;
28202                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
28203                                         ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
28204                                         free(idx_2);
28205                                 }
28206                         }
28207                         ndr->depth--;
28208                 }
28209                 ndr->depth--;
28210                 ndr->depth--;
28211                 ndr_print_ptr(ndr, "needed", r->out.needed);
28212                 ndr->depth++;
28213                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28214                 ndr->depth--;
28215                 ndr_print_WERROR(ndr, "result", r->out.result);
28216                 ndr->depth--;
28217         }
28218         ndr->depth--;
28219 }
28220
28221 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
28222 {
28223         if (flags & NDR_IN) {
28224                 if (r->in.handle == NULL) {
28225                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28226                 }
28227                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28228                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28229                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28230                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28231                 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));
28232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28233         }
28234         if (flags & NDR_OUT) {
28235                 if (r->out._ndr_size == NULL) {
28236                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28237                 }
28238                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._ndr_size));
28239                 if (r->out.key_buffer == NULL) {
28240                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28241                 }
28242                 {
28243                         struct ndr_push *_ndr_key_buffer;
28244                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
28245                         NDR_CHECK(ndr_push_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
28246                         NDR_CHECK(ndr_push_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
28247                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
28248                 }
28249                 if (r->out.needed == NULL) {
28250                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28251                 }
28252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28253                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28254         }
28255         return NDR_ERR_SUCCESS;
28256 }
28257
28258 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
28259 {
28260         TALLOC_CTX *_mem_save_handle_0;
28261         TALLOC_CTX *_mem_save__ndr_size_0;
28262         TALLOC_CTX *_mem_save_key_buffer_0;
28263         TALLOC_CTX *_mem_save_needed_0;
28264         if (flags & NDR_IN) {
28265                 ZERO_STRUCT(r->out);
28266
28267                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28268                         NDR_PULL_ALLOC(ndr, r->in.handle);
28269                 }
28270                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28271                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28272                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28273                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28274                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28275                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28276                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28277                         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));
28278                 }
28279                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28280                 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));
28281                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28282                 NDR_PULL_ALLOC(ndr, r->out._ndr_size);
28283                 ZERO_STRUCTP(r->out._ndr_size);
28284                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
28285                 ZERO_STRUCTP(r->out.key_buffer);
28286                 NDR_PULL_ALLOC(ndr, r->out.needed);
28287                 ZERO_STRUCTP(r->out.needed);
28288         }
28289         if (flags & NDR_OUT) {
28290                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28291                         NDR_PULL_ALLOC(ndr, r->out._ndr_size);
28292                 }
28293                 _mem_save__ndr_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
28294                 NDR_PULL_SET_MEM_CTX(ndr, r->out._ndr_size, LIBNDR_FLAG_REF_ALLOC);
28295                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._ndr_size));
28296                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__ndr_size_0, LIBNDR_FLAG_REF_ALLOC);
28297                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28298                         NDR_PULL_ALLOC(ndr, r->out.key_buffer);
28299                 }
28300                 _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
28301                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
28302                 {
28303                         struct ndr_pull *_ndr_key_buffer;
28304                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
28305                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
28306                         NDR_CHECK(ndr_pull_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
28307                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
28308                 }
28309                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
28310                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28311                         NDR_PULL_ALLOC(ndr, r->out.needed);
28312                 }
28313                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28314                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28315                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28316                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28317                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28318         }
28319         return NDR_ERR_SUCCESS;
28320 }
28321
28322 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
28323 {
28324         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
28325         ndr->depth++;
28326         if (flags & NDR_SET_VALUES) {
28327                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28328         }
28329         if (flags & NDR_IN) {
28330                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
28331                 ndr->depth++;
28332                 ndr_print_ptr(ndr, "handle", r->in.handle);
28333                 ndr->depth++;
28334                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28335                 ndr->depth--;
28336                 ndr_print_string(ndr, "key_name", r->in.key_name);
28337                 ndr_print_uint32(ndr, "offered", r->in.offered);
28338                 ndr->depth--;
28339         }
28340         if (flags & NDR_OUT) {
28341                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
28342                 ndr->depth++;
28343                 ndr_print_ptr(ndr, "_ndr_size", r->out._ndr_size);
28344                 ndr->depth++;
28345                 ndr_print_uint32(ndr, "_ndr_size", *r->out._ndr_size);
28346                 ndr->depth--;
28347                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
28348                 ndr->depth++;
28349                 ndr_print_set_switch_value(ndr, r->out.key_buffer, *r->out._ndr_size);
28350                 ndr_print_spoolss_KeyNames(ndr, "key_buffer", r->out.key_buffer);
28351                 ndr->depth--;
28352                 ndr_print_ptr(ndr, "needed", r->out.needed);
28353                 ndr->depth++;
28354                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28355                 ndr->depth--;
28356                 ndr_print_WERROR(ndr, "result", r->out.result);
28357                 ndr->depth--;
28358         }
28359         ndr->depth--;
28360 }
28361
28362 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
28363 {
28364         if (flags & NDR_IN) {
28365                 if (r->in.handle == NULL) {
28366                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28367                 }
28368                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28369                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28370                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28371                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28372                 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));
28373                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28374                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28375                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28376                 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));
28377         }
28378         if (flags & NDR_OUT) {
28379                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28380         }
28381         return NDR_ERR_SUCCESS;
28382 }
28383
28384 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
28385 {
28386         TALLOC_CTX *_mem_save_handle_0;
28387         if (flags & NDR_IN) {
28388                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28389                         NDR_PULL_ALLOC(ndr, r->in.handle);
28390                 }
28391                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28392                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28393                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28394                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28395                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28396                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28397                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28398                         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));
28399                 }
28400                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28401                 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));
28402                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28403                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28404                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28405                         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));
28406                 }
28407                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28408                 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));
28409         }
28410         if (flags & NDR_OUT) {
28411                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28412         }
28413         return NDR_ERR_SUCCESS;
28414 }
28415
28416 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
28417 {
28418         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
28419         ndr->depth++;
28420         if (flags & NDR_SET_VALUES) {
28421                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28422         }
28423         if (flags & NDR_IN) {
28424                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
28425                 ndr->depth++;
28426                 ndr_print_ptr(ndr, "handle", r->in.handle);
28427                 ndr->depth++;
28428                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28429                 ndr->depth--;
28430                 ndr_print_string(ndr, "key_name", r->in.key_name);
28431                 ndr_print_string(ndr, "value_name", r->in.value_name);
28432                 ndr->depth--;
28433         }
28434         if (flags & NDR_OUT) {
28435                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
28436                 ndr->depth++;
28437                 ndr_print_WERROR(ndr, "result", r->out.result);
28438                 ndr->depth--;
28439         }
28440         ndr->depth--;
28441 }
28442
28443 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
28444 {
28445         if (flags & NDR_IN) {
28446                 if (r->in.handle == NULL) {
28447                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28448                 }
28449                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28450                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28451                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28452                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28453                 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));
28454         }
28455         if (flags & NDR_OUT) {
28456                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28457         }
28458         return NDR_ERR_SUCCESS;
28459 }
28460
28461 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
28462 {
28463         TALLOC_CTX *_mem_save_handle_0;
28464         if (flags & NDR_IN) {
28465                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28466                         NDR_PULL_ALLOC(ndr, r->in.handle);
28467                 }
28468                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28469                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28470                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28471                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28472                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28473                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28474                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28475                         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));
28476                 }
28477                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28478                 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));
28479         }
28480         if (flags & NDR_OUT) {
28481                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28482         }
28483         return NDR_ERR_SUCCESS;
28484 }
28485
28486 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
28487 {
28488         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
28489         ndr->depth++;
28490         if (flags & NDR_SET_VALUES) {
28491                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28492         }
28493         if (flags & NDR_IN) {
28494                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
28495                 ndr->depth++;
28496                 ndr_print_ptr(ndr, "handle", r->in.handle);
28497                 ndr->depth++;
28498                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28499                 ndr->depth--;
28500                 ndr_print_string(ndr, "key_name", r->in.key_name);
28501                 ndr->depth--;
28502         }
28503         if (flags & NDR_OUT) {
28504                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
28505                 ndr->depth++;
28506                 ndr_print_WERROR(ndr, "result", r->out.result);
28507                 ndr->depth--;
28508         }
28509         ndr->depth--;
28510 }
28511
28512 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
28513 {
28514         if (flags & NDR_IN) {
28515         }
28516         if (flags & NDR_OUT) {
28517                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28518         }
28519         return NDR_ERR_SUCCESS;
28520 }
28521
28522 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
28523 {
28524         if (flags & NDR_IN) {
28525         }
28526         if (flags & NDR_OUT) {
28527                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28528         }
28529         return NDR_ERR_SUCCESS;
28530 }
28531
28532 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
28533 {
28534         ndr_print_struct(ndr, name, "spoolss_53");
28535         ndr->depth++;
28536         if (flags & NDR_SET_VALUES) {
28537                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28538         }
28539         if (flags & NDR_IN) {
28540                 ndr_print_struct(ndr, "in", "spoolss_53");
28541                 ndr->depth++;
28542                 ndr->depth--;
28543         }
28544         if (flags & NDR_OUT) {
28545                 ndr_print_struct(ndr, "out", "spoolss_53");
28546                 ndr->depth++;
28547                 ndr_print_WERROR(ndr, "result", r->out.result);
28548                 ndr->depth--;
28549         }
28550         ndr->depth--;
28551 }
28552
28553 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
28554 {
28555         if (flags & NDR_IN) {
28556                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
28557                 if (r->in.server) {
28558                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
28559                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28560                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
28561                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28562                 }
28563                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
28564                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28565                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
28566                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28567                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
28568                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28569                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
28570                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28571                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
28572                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
28573         }
28574         if (flags & NDR_OUT) {
28575                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28576         }
28577         return NDR_ERR_SUCCESS;
28578 }
28579
28580 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
28581 {
28582         uint32_t _ptr_server;
28583         TALLOC_CTX *_mem_save_server_0;
28584         if (flags & NDR_IN) {
28585                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
28586                 if (_ptr_server) {
28587                         NDR_PULL_ALLOC(ndr, r->in.server);
28588                 } else {
28589                         r->in.server = NULL;
28590                 }
28591                 if (r->in.server) {
28592                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
28593                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
28594                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
28595                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
28596                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
28597                                 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));
28598                         }
28599                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
28600                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
28601                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
28602                 }
28603                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
28604                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
28605                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
28606                         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));
28607                 }
28608                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
28609                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
28610                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
28611                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
28612                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
28613                         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));
28614                 }
28615                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
28616                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
28617                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
28618                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
28619         }
28620         if (flags & NDR_OUT) {
28621                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28622         }
28623         return NDR_ERR_SUCCESS;
28624 }
28625
28626 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
28627 {
28628         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
28629         ndr->depth++;
28630         if (flags & NDR_SET_VALUES) {
28631                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28632         }
28633         if (flags & NDR_IN) {
28634                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
28635                 ndr->depth++;
28636                 ndr_print_ptr(ndr, "server", r->in.server);
28637                 ndr->depth++;
28638                 if (r->in.server) {
28639                         ndr_print_string(ndr, "server", r->in.server);
28640                 }
28641                 ndr->depth--;
28642                 ndr_print_string(ndr, "architecture", r->in.architecture);
28643                 ndr_print_string(ndr, "driver", r->in.driver);
28644                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
28645                 ndr_print_uint32(ndr, "version", r->in.version);
28646                 ndr->depth--;
28647         }
28648         if (flags & NDR_OUT) {
28649                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
28650                 ndr->depth++;
28651                 ndr_print_WERROR(ndr, "result", r->out.result);
28652                 ndr->depth--;
28653         }
28654         ndr->depth--;
28655 }
28656
28657 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
28658 {
28659         if (flags & NDR_IN) {
28660         }
28661         if (flags & NDR_OUT) {
28662                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28663         }
28664         return NDR_ERR_SUCCESS;
28665 }
28666
28667 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
28668 {
28669         if (flags & NDR_IN) {
28670         }
28671         if (flags & NDR_OUT) {
28672                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28673         }
28674         return NDR_ERR_SUCCESS;
28675 }
28676
28677 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
28678 {
28679         ndr_print_struct(ndr, name, "spoolss_55");
28680         ndr->depth++;
28681         if (flags & NDR_SET_VALUES) {
28682                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28683         }
28684         if (flags & NDR_IN) {
28685                 ndr_print_struct(ndr, "in", "spoolss_55");
28686                 ndr->depth++;
28687                 ndr->depth--;
28688         }
28689         if (flags & NDR_OUT) {
28690                 ndr_print_struct(ndr, "out", "spoolss_55");
28691                 ndr->depth++;
28692                 ndr_print_WERROR(ndr, "result", r->out.result);
28693                 ndr->depth--;
28694         }
28695         ndr->depth--;
28696 }
28697
28698 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
28699 {
28700         if (flags & NDR_IN) {
28701         }
28702         if (flags & NDR_OUT) {
28703                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28704         }
28705         return NDR_ERR_SUCCESS;
28706 }
28707
28708 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
28709 {
28710         if (flags & NDR_IN) {
28711         }
28712         if (flags & NDR_OUT) {
28713                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28714         }
28715         return NDR_ERR_SUCCESS;
28716 }
28717
28718 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
28719 {
28720         ndr_print_struct(ndr, name, "spoolss_56");
28721         ndr->depth++;
28722         if (flags & NDR_SET_VALUES) {
28723                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28724         }
28725         if (flags & NDR_IN) {
28726                 ndr_print_struct(ndr, "in", "spoolss_56");
28727                 ndr->depth++;
28728                 ndr->depth--;
28729         }
28730         if (flags & NDR_OUT) {
28731                 ndr_print_struct(ndr, "out", "spoolss_56");
28732                 ndr->depth++;
28733                 ndr_print_WERROR(ndr, "result", r->out.result);
28734                 ndr->depth--;
28735         }
28736         ndr->depth--;
28737 }
28738
28739 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
28740 {
28741         if (flags & NDR_IN) {
28742         }
28743         if (flags & NDR_OUT) {
28744                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28745         }
28746         return NDR_ERR_SUCCESS;
28747 }
28748
28749 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
28750 {
28751         if (flags & NDR_IN) {
28752         }
28753         if (flags & NDR_OUT) {
28754                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28755         }
28756         return NDR_ERR_SUCCESS;
28757 }
28758
28759 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
28760 {
28761         ndr_print_struct(ndr, name, "spoolss_57");
28762         ndr->depth++;
28763         if (flags & NDR_SET_VALUES) {
28764                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28765         }
28766         if (flags & NDR_IN) {
28767                 ndr_print_struct(ndr, "in", "spoolss_57");
28768                 ndr->depth++;
28769                 ndr->depth--;
28770         }
28771         if (flags & NDR_OUT) {
28772                 ndr_print_struct(ndr, "out", "spoolss_57");
28773                 ndr->depth++;
28774                 ndr_print_WERROR(ndr, "result", r->out.result);
28775                 ndr->depth--;
28776         }
28777         ndr->depth--;
28778 }
28779
28780 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
28781 {
28782         if (flags & NDR_IN) {
28783                 if (r->in.handle == NULL) {
28784                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28785                 }
28786                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28787                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
28788                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28789                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
28790                 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));
28791                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
28792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
28793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
28794                 if (r->in.status_code == NULL) {
28795                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28796                 }
28797                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
28798         }
28799         if (flags & NDR_OUT) {
28800                 if (r->out.out_data == NULL) {
28801                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28802                 }
28803                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.out_data_size));
28804                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
28805                 if (r->out.needed == NULL) {
28806                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28807                 }
28808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28809                 if (r->out.status_code == NULL) {
28810                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28811                 }
28812                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
28813                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28814         }
28815         return NDR_ERR_SUCCESS;
28816 }
28817
28818 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
28819 {
28820         TALLOC_CTX *_mem_save_handle_0;
28821         TALLOC_CTX *_mem_save_needed_0;
28822         TALLOC_CTX *_mem_save_status_code_0;
28823         if (flags & NDR_IN) {
28824                 ZERO_STRUCT(r->out);
28825
28826                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28827                         NDR_PULL_ALLOC(ndr, r->in.handle);
28828                 }
28829                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28830                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28831                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28832                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28833                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
28834                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
28835                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
28836                         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));
28837                 }
28838                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
28839                 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));
28840                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
28841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
28842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
28843                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28844                         NDR_PULL_ALLOC(ndr, r->in.status_code);
28845                 }
28846                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
28847                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
28848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
28849                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
28850                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
28851                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
28852                 NDR_PULL_ALLOC(ndr, r->out.needed);
28853                 ZERO_STRUCTP(r->out.needed);
28854                 NDR_PULL_ALLOC(ndr, r->out.status_code);
28855                 *r->out.status_code = *r->in.status_code;
28856         }
28857         if (flags & NDR_OUT) {
28858                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
28859                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28860                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
28861                 }
28862                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
28863                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28864                         NDR_PULL_ALLOC(ndr, r->out.needed);
28865                 }
28866                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28867                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28868                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28869                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28870                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28871                         NDR_PULL_ALLOC(ndr, r->out.status_code);
28872                 }
28873                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
28874                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
28875                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
28876                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
28877                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28878                 if (r->out.out_data) {
28879                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
28880                 }
28881         }
28882         return NDR_ERR_SUCCESS;
28883 }
28884
28885 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
28886 {
28887         ndr_print_struct(ndr, name, "spoolss_XcvData");
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_XcvData");
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, "function_name", r->in.function_name);
28900                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
28901                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
28902                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
28903                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
28904                 ndr->depth++;
28905                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
28906                 ndr->depth--;
28907                 ndr->depth--;
28908         }
28909         if (flags & NDR_OUT) {
28910                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
28911                 ndr->depth++;
28912                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
28913                 ndr->depth++;
28914                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
28915                 ndr->depth--;
28916                 ndr_print_ptr(ndr, "needed", r->out.needed);
28917                 ndr->depth++;
28918                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28919                 ndr->depth--;
28920                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
28921                 ndr->depth++;
28922                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
28923                 ndr->depth--;
28924                 ndr_print_WERROR(ndr, "result", r->out.result);
28925                 ndr->depth--;
28926         }
28927         ndr->depth--;
28928 }
28929
28930 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
28931 {
28932         if (flags & NDR_IN) {
28933                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
28934                 if (r->in.servername) {
28935                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
28936                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28937                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
28938                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28939                 }
28940                 if (r->in.info_ctr == NULL) {
28941                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28942                 }
28943                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
28944                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
28945         }
28946         if (flags & NDR_OUT) {
28947                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28948         }
28949         return NDR_ERR_SUCCESS;
28950 }
28951
28952 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
28953 {
28954         uint32_t _ptr_servername;
28955         TALLOC_CTX *_mem_save_servername_0;
28956         TALLOC_CTX *_mem_save_info_ctr_0;
28957         if (flags & NDR_IN) {
28958                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
28959                 if (_ptr_servername) {
28960                         NDR_PULL_ALLOC(ndr, r->in.servername);
28961                 } else {
28962                         r->in.servername = NULL;
28963                 }
28964                 if (r->in.servername) {
28965                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
28966                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
28967                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
28968                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
28969                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
28970                                 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));
28971                         }
28972                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
28973                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
28974                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
28975                 }
28976                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28977                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
28978                 }
28979                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
28980                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
28981                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
28982                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
28983                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
28984         }
28985         if (flags & NDR_OUT) {
28986                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28987         }
28988         return NDR_ERR_SUCCESS;
28989 }
28990
28991 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
28992 {
28993         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
28994         ndr->depth++;
28995         if (flags & NDR_SET_VALUES) {
28996                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28997         }
28998         if (flags & NDR_IN) {
28999                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
29000                 ndr->depth++;
29001                 ndr_print_ptr(ndr, "servername", r->in.servername);
29002                 ndr->depth++;
29003                 if (r->in.servername) {
29004                         ndr_print_string(ndr, "servername", r->in.servername);
29005                 }
29006                 ndr->depth--;
29007                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
29008                 ndr->depth++;
29009                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
29010                 ndr->depth--;
29011                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
29012                 ndr->depth--;
29013         }
29014         if (flags & NDR_OUT) {
29015                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
29016                 ndr->depth++;
29017                 ndr_print_WERROR(ndr, "result", r->out.result);
29018                 ndr->depth--;
29019         }
29020         ndr->depth--;
29021 }
29022
29023 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
29024 {
29025         if (flags & NDR_IN) {
29026         }
29027         if (flags & NDR_OUT) {
29028                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29029         }
29030         return NDR_ERR_SUCCESS;
29031 }
29032
29033 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
29034 {
29035         if (flags & NDR_IN) {
29036         }
29037         if (flags & NDR_OUT) {
29038                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29039         }
29040         return NDR_ERR_SUCCESS;
29041 }
29042
29043 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
29044 {
29045         ndr_print_struct(ndr, name, "spoolss_5a");
29046         ndr->depth++;
29047         if (flags & NDR_SET_VALUES) {
29048                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29049         }
29050         if (flags & NDR_IN) {
29051                 ndr_print_struct(ndr, "in", "spoolss_5a");
29052                 ndr->depth++;
29053                 ndr->depth--;
29054         }
29055         if (flags & NDR_OUT) {
29056                 ndr_print_struct(ndr, "out", "spoolss_5a");
29057                 ndr->depth++;
29058                 ndr_print_WERROR(ndr, "result", r->out.result);
29059                 ndr->depth--;
29060         }
29061         ndr->depth--;
29062 }
29063
29064 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
29065 {
29066         if (flags & NDR_IN) {
29067         }
29068         if (flags & NDR_OUT) {
29069                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29070         }
29071         return NDR_ERR_SUCCESS;
29072 }
29073
29074 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
29075 {
29076         if (flags & NDR_IN) {
29077         }
29078         if (flags & NDR_OUT) {
29079                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29080         }
29081         return NDR_ERR_SUCCESS;
29082 }
29083
29084 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
29085 {
29086         ndr_print_struct(ndr, name, "spoolss_5b");
29087         ndr->depth++;
29088         if (flags & NDR_SET_VALUES) {
29089                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29090         }
29091         if (flags & NDR_IN) {
29092                 ndr_print_struct(ndr, "in", "spoolss_5b");
29093                 ndr->depth++;
29094                 ndr->depth--;
29095         }
29096         if (flags & NDR_OUT) {
29097                 ndr_print_struct(ndr, "out", "spoolss_5b");
29098                 ndr->depth++;
29099                 ndr_print_WERROR(ndr, "result", r->out.result);
29100                 ndr->depth--;
29101         }
29102         ndr->depth--;
29103 }
29104
29105 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
29106 {
29107         if (flags & NDR_IN) {
29108         }
29109         if (flags & NDR_OUT) {
29110                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29111         }
29112         return NDR_ERR_SUCCESS;
29113 }
29114
29115 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
29116 {
29117         if (flags & NDR_IN) {
29118         }
29119         if (flags & NDR_OUT) {
29120                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29121         }
29122         return NDR_ERR_SUCCESS;
29123 }
29124
29125 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
29126 {
29127         ndr_print_struct(ndr, name, "spoolss_5c");
29128         ndr->depth++;
29129         if (flags & NDR_SET_VALUES) {
29130                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29131         }
29132         if (flags & NDR_IN) {
29133                 ndr_print_struct(ndr, "in", "spoolss_5c");
29134                 ndr->depth++;
29135                 ndr->depth--;
29136         }
29137         if (flags & NDR_OUT) {
29138                 ndr_print_struct(ndr, "out", "spoolss_5c");
29139                 ndr->depth++;
29140                 ndr_print_WERROR(ndr, "result", r->out.result);
29141                 ndr->depth--;
29142         }
29143         ndr->depth--;
29144 }
29145
29146 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
29147 {
29148         if (flags & NDR_IN) {
29149         }
29150         if (flags & NDR_OUT) {
29151                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29152         }
29153         return NDR_ERR_SUCCESS;
29154 }
29155
29156 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
29157 {
29158         if (flags & NDR_IN) {
29159         }
29160         if (flags & NDR_OUT) {
29161                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29162         }
29163         return NDR_ERR_SUCCESS;
29164 }
29165
29166 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
29167 {
29168         ndr_print_struct(ndr, name, "spoolss_5d");
29169         ndr->depth++;
29170         if (flags & NDR_SET_VALUES) {
29171                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29172         }
29173         if (flags & NDR_IN) {
29174                 ndr_print_struct(ndr, "in", "spoolss_5d");
29175                 ndr->depth++;
29176                 ndr->depth--;
29177         }
29178         if (flags & NDR_OUT) {
29179                 ndr_print_struct(ndr, "out", "spoolss_5d");
29180                 ndr->depth++;
29181                 ndr_print_WERROR(ndr, "result", r->out.result);
29182                 ndr->depth--;
29183         }
29184         ndr->depth--;
29185 }
29186
29187 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
29188 {
29189         if (flags & NDR_IN) {
29190         }
29191         if (flags & NDR_OUT) {
29192                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29193         }
29194         return NDR_ERR_SUCCESS;
29195 }
29196
29197 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
29198 {
29199         if (flags & NDR_IN) {
29200         }
29201         if (flags & NDR_OUT) {
29202                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29203         }
29204         return NDR_ERR_SUCCESS;
29205 }
29206
29207 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
29208 {
29209         ndr_print_struct(ndr, name, "spoolss_5e");
29210         ndr->depth++;
29211         if (flags & NDR_SET_VALUES) {
29212                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29213         }
29214         if (flags & NDR_IN) {
29215                 ndr_print_struct(ndr, "in", "spoolss_5e");
29216                 ndr->depth++;
29217                 ndr->depth--;
29218         }
29219         if (flags & NDR_OUT) {
29220                 ndr_print_struct(ndr, "out", "spoolss_5e");
29221                 ndr->depth++;
29222                 ndr_print_WERROR(ndr, "result", r->out.result);
29223                 ndr->depth--;
29224         }
29225         ndr->depth--;
29226 }
29227
29228 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
29229 {
29230         if (flags & NDR_IN) {
29231         }
29232         if (flags & NDR_OUT) {
29233                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29234         }
29235         return NDR_ERR_SUCCESS;
29236 }
29237
29238 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
29239 {
29240         if (flags & NDR_IN) {
29241         }
29242         if (flags & NDR_OUT) {
29243                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29244         }
29245         return NDR_ERR_SUCCESS;
29246 }
29247
29248 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
29249 {
29250         ndr_print_struct(ndr, name, "spoolss_5f");
29251         ndr->depth++;
29252         if (flags & NDR_SET_VALUES) {
29253                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29254         }
29255         if (flags & NDR_IN) {
29256                 ndr_print_struct(ndr, "in", "spoolss_5f");
29257                 ndr->depth++;
29258                 ndr->depth--;
29259         }
29260         if (flags & NDR_OUT) {
29261                 ndr_print_struct(ndr, "out", "spoolss_5f");
29262                 ndr->depth++;
29263                 ndr_print_WERROR(ndr, "result", r->out.result);
29264                 ndr->depth--;
29265         }
29266         ndr->depth--;
29267 }
29268
29269 static enum ndr_err_code ndr_push_spoolss_60(struct ndr_push *ndr, int flags, const struct spoolss_60 *r)
29270 {
29271         if (flags & NDR_IN) {
29272         }
29273         if (flags & NDR_OUT) {
29274                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29275         }
29276         return NDR_ERR_SUCCESS;
29277 }
29278
29279 static enum ndr_err_code ndr_pull_spoolss_60(struct ndr_pull *ndr, int flags, struct spoolss_60 *r)
29280 {
29281         if (flags & NDR_IN) {
29282         }
29283         if (flags & NDR_OUT) {
29284                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29285         }
29286         return NDR_ERR_SUCCESS;
29287 }
29288
29289 _PUBLIC_ void ndr_print_spoolss_60(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_60 *r)
29290 {
29291         ndr_print_struct(ndr, name, "spoolss_60");
29292         ndr->depth++;
29293         if (flags & NDR_SET_VALUES) {
29294                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29295         }
29296         if (flags & NDR_IN) {
29297                 ndr_print_struct(ndr, "in", "spoolss_60");
29298                 ndr->depth++;
29299                 ndr->depth--;
29300         }
29301         if (flags & NDR_OUT) {
29302                 ndr_print_struct(ndr, "out", "spoolss_60");
29303                 ndr->depth++;
29304                 ndr_print_WERROR(ndr, "result", r->out.result);
29305                 ndr->depth--;
29306         }
29307         ndr->depth--;
29308 }
29309
29310 static enum ndr_err_code ndr_push_spoolss_61(struct ndr_push *ndr, int flags, const struct spoolss_61 *r)
29311 {
29312         if (flags & NDR_IN) {
29313         }
29314         if (flags & NDR_OUT) {
29315                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29316         }
29317         return NDR_ERR_SUCCESS;
29318 }
29319
29320 static enum ndr_err_code ndr_pull_spoolss_61(struct ndr_pull *ndr, int flags, struct spoolss_61 *r)
29321 {
29322         if (flags & NDR_IN) {
29323         }
29324         if (flags & NDR_OUT) {
29325                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29326         }
29327         return NDR_ERR_SUCCESS;
29328 }
29329
29330 _PUBLIC_ void ndr_print_spoolss_61(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_61 *r)
29331 {
29332         ndr_print_struct(ndr, name, "spoolss_61");
29333         ndr->depth++;
29334         if (flags & NDR_SET_VALUES) {
29335                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29336         }
29337         if (flags & NDR_IN) {
29338                 ndr_print_struct(ndr, "in", "spoolss_61");
29339                 ndr->depth++;
29340                 ndr->depth--;
29341         }
29342         if (flags & NDR_OUT) {
29343                 ndr_print_struct(ndr, "out", "spoolss_61");
29344                 ndr->depth++;
29345                 ndr_print_WERROR(ndr, "result", r->out.result);
29346                 ndr->depth--;
29347         }
29348         ndr->depth--;
29349 }
29350
29351 static enum ndr_err_code ndr_push_spoolss_62(struct ndr_push *ndr, int flags, const struct spoolss_62 *r)
29352 {
29353         if (flags & NDR_IN) {
29354         }
29355         if (flags & NDR_OUT) {
29356                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29357         }
29358         return NDR_ERR_SUCCESS;
29359 }
29360
29361 static enum ndr_err_code ndr_pull_spoolss_62(struct ndr_pull *ndr, int flags, struct spoolss_62 *r)
29362 {
29363         if (flags & NDR_IN) {
29364         }
29365         if (flags & NDR_OUT) {
29366                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29367         }
29368         return NDR_ERR_SUCCESS;
29369 }
29370
29371 _PUBLIC_ void ndr_print_spoolss_62(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_62 *r)
29372 {
29373         ndr_print_struct(ndr, name, "spoolss_62");
29374         ndr->depth++;
29375         if (flags & NDR_SET_VALUES) {
29376                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29377         }
29378         if (flags & NDR_IN) {
29379                 ndr_print_struct(ndr, "in", "spoolss_62");
29380                 ndr->depth++;
29381                 ndr->depth--;
29382         }
29383         if (flags & NDR_OUT) {
29384                 ndr_print_struct(ndr, "out", "spoolss_62");
29385                 ndr->depth++;
29386                 ndr_print_WERROR(ndr, "result", r->out.result);
29387                 ndr->depth--;
29388         }
29389         ndr->depth--;
29390 }
29391
29392 static enum ndr_err_code ndr_push_spoolss_63(struct ndr_push *ndr, int flags, const struct spoolss_63 *r)
29393 {
29394         if (flags & NDR_IN) {
29395         }
29396         if (flags & NDR_OUT) {
29397                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29398         }
29399         return NDR_ERR_SUCCESS;
29400 }
29401
29402 static enum ndr_err_code ndr_pull_spoolss_63(struct ndr_pull *ndr, int flags, struct spoolss_63 *r)
29403 {
29404         if (flags & NDR_IN) {
29405         }
29406         if (flags & NDR_OUT) {
29407                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29408         }
29409         return NDR_ERR_SUCCESS;
29410 }
29411
29412 _PUBLIC_ void ndr_print_spoolss_63(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_63 *r)
29413 {
29414         ndr_print_struct(ndr, name, "spoolss_63");
29415         ndr->depth++;
29416         if (flags & NDR_SET_VALUES) {
29417                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29418         }
29419         if (flags & NDR_IN) {
29420                 ndr_print_struct(ndr, "in", "spoolss_63");
29421                 ndr->depth++;
29422                 ndr->depth--;
29423         }
29424         if (flags & NDR_OUT) {
29425                 ndr_print_struct(ndr, "out", "spoolss_63");
29426                 ndr->depth++;
29427                 ndr_print_WERROR(ndr, "result", r->out.result);
29428                 ndr->depth--;
29429         }
29430         ndr->depth--;
29431 }
29432
29433 static enum ndr_err_code ndr_push_spoolss_64(struct ndr_push *ndr, int flags, const struct spoolss_64 *r)
29434 {
29435         if (flags & NDR_IN) {
29436         }
29437         if (flags & NDR_OUT) {
29438                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29439         }
29440         return NDR_ERR_SUCCESS;
29441 }
29442
29443 static enum ndr_err_code ndr_pull_spoolss_64(struct ndr_pull *ndr, int flags, struct spoolss_64 *r)
29444 {
29445         if (flags & NDR_IN) {
29446         }
29447         if (flags & NDR_OUT) {
29448                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29449         }
29450         return NDR_ERR_SUCCESS;
29451 }
29452
29453 _PUBLIC_ void ndr_print_spoolss_64(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_64 *r)
29454 {
29455         ndr_print_struct(ndr, name, "spoolss_64");
29456         ndr->depth++;
29457         if (flags & NDR_SET_VALUES) {
29458                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29459         }
29460         if (flags & NDR_IN) {
29461                 ndr_print_struct(ndr, "in", "spoolss_64");
29462                 ndr->depth++;
29463                 ndr->depth--;
29464         }
29465         if (flags & NDR_OUT) {
29466                 ndr_print_struct(ndr, "out", "spoolss_64");
29467                 ndr->depth++;
29468                 ndr_print_WERROR(ndr, "result", r->out.result);
29469                 ndr->depth--;
29470         }
29471         ndr->depth--;
29472 }
29473
29474 static enum ndr_err_code ndr_push_spoolss_65(struct ndr_push *ndr, int flags, const struct spoolss_65 *r)
29475 {
29476         if (flags & NDR_IN) {
29477         }
29478         if (flags & NDR_OUT) {
29479                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29480         }
29481         return NDR_ERR_SUCCESS;
29482 }
29483
29484 static enum ndr_err_code ndr_pull_spoolss_65(struct ndr_pull *ndr, int flags, struct spoolss_65 *r)
29485 {
29486         if (flags & NDR_IN) {
29487         }
29488         if (flags & NDR_OUT) {
29489                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29490         }
29491         return NDR_ERR_SUCCESS;
29492 }
29493
29494 _PUBLIC_ void ndr_print_spoolss_65(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_65 *r)
29495 {
29496         ndr_print_struct(ndr, name, "spoolss_65");
29497         ndr->depth++;
29498         if (flags & NDR_SET_VALUES) {
29499                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29500         }
29501         if (flags & NDR_IN) {
29502                 ndr_print_struct(ndr, "in", "spoolss_65");
29503                 ndr->depth++;
29504                 ndr->depth--;
29505         }
29506         if (flags & NDR_OUT) {
29507                 ndr_print_struct(ndr, "out", "spoolss_65");
29508                 ndr->depth++;
29509                 ndr_print_WERROR(ndr, "result", r->out.result);
29510                 ndr->depth--;
29511         }
29512         ndr->depth--;
29513 }
29514
29515 static enum ndr_err_code ndr_push_spoolss_GetCorePrinterDrivers(struct ndr_push *ndr, int flags, const struct spoolss_GetCorePrinterDrivers *r)
29516 {
29517         uint32_t cntr_core_printer_drivers_1;
29518         if (flags & NDR_IN) {
29519                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29520                 if (r->in.servername) {
29521                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29522                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29523                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29524                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29525                 }
29526                 if (r->in.architecture == NULL) {
29527                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29528                 }
29529                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29530                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29531                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29532                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_driver_size));
29534                 if (r->in.core_driver_dependencies == NULL) {
29535                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29536                 }
29537                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_driver_size));
29538                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.core_driver_dependencies, r->in.core_driver_size, sizeof(uint16_t), CH_UTF16));
29539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
29540         }
29541         if (flags & NDR_OUT) {
29542                 if (r->out.core_printer_drivers == NULL) {
29543                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29544                 }
29545                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
29546                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
29547                         NDR_CHECK(ndr_push_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
29548                 }
29549                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29550         }
29551         return NDR_ERR_SUCCESS;
29552 }
29553
29554 static enum ndr_err_code ndr_pull_spoolss_GetCorePrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_GetCorePrinterDrivers *r)
29555 {
29556         uint32_t _ptr_servername;
29557         uint32_t cntr_core_printer_drivers_1;
29558         TALLOC_CTX *_mem_save_servername_0;
29559         TALLOC_CTX *_mem_save_core_printer_drivers_1;
29560         if (flags & NDR_IN) {
29561                 ZERO_STRUCT(r->out);
29562
29563                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29564                 if (_ptr_servername) {
29565                         NDR_PULL_ALLOC(ndr, r->in.servername);
29566                 } else {
29567                         r->in.servername = NULL;
29568                 }
29569                 if (r->in.servername) {
29570                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29571                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29572                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29573                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29574                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29575                                 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));
29576                         }
29577                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29578                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29579                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29580                 }
29581                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
29582                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
29583                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
29584                         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));
29585                 }
29586                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
29587                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
29588                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_driver_size));
29589                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.core_driver_dependencies));
29590                 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));
29591                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_printer_driver_count));
29592                 NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, r->in.core_printer_driver_count);
29593                 memset(r->out.core_printer_drivers, 0, (r->in.core_printer_driver_count) * sizeof(*r->out.core_printer_drivers));
29594                 if (r->in.core_driver_dependencies) {
29595                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.core_driver_dependencies, r->in.core_driver_size));
29596                 }
29597         }
29598         if (flags & NDR_OUT) {
29599                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.core_printer_drivers));
29600                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29601                         NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, ndr_get_array_size(ndr, &r->out.core_printer_drivers));
29602                 }
29603                 _mem_save_core_printer_drivers_1 = NDR_PULL_GET_MEM_CTX(ndr);
29604                 NDR_PULL_SET_MEM_CTX(ndr, r->out.core_printer_drivers, 0);
29605                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
29606                         NDR_CHECK(ndr_pull_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
29607                 }
29608                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_printer_drivers_1, 0);
29609                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29610                 if (r->out.core_printer_drivers) {
29611                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.core_printer_drivers, r->in.core_printer_driver_count));
29612                 }
29613         }
29614         return NDR_ERR_SUCCESS;
29615 }
29616
29617 _PUBLIC_ void ndr_print_spoolss_GetCorePrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetCorePrinterDrivers *r)
29618 {
29619         uint32_t cntr_core_printer_drivers_1;
29620         ndr_print_struct(ndr, name, "spoolss_GetCorePrinterDrivers");
29621         ndr->depth++;
29622         if (flags & NDR_SET_VALUES) {
29623                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29624         }
29625         if (flags & NDR_IN) {
29626                 ndr_print_struct(ndr, "in", "spoolss_GetCorePrinterDrivers");
29627                 ndr->depth++;
29628                 ndr_print_ptr(ndr, "servername", r->in.servername);
29629                 ndr->depth++;
29630                 if (r->in.servername) {
29631                         ndr_print_string(ndr, "servername", r->in.servername);
29632                 }
29633                 ndr->depth--;
29634                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
29635                 ndr->depth++;
29636                 ndr_print_string(ndr, "architecture", r->in.architecture);
29637                 ndr->depth--;
29638                 ndr_print_uint32(ndr, "core_driver_size", r->in.core_driver_size);
29639                 ndr_print_ptr(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
29640                 ndr->depth++;
29641                 ndr_print_string(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
29642                 ndr->depth--;
29643                 ndr_print_uint32(ndr, "core_printer_driver_count", r->in.core_printer_driver_count);
29644                 ndr->depth--;
29645         }
29646         if (flags & NDR_OUT) {
29647                 ndr_print_struct(ndr, "out", "spoolss_GetCorePrinterDrivers");
29648                 ndr->depth++;
29649                 ndr_print_ptr(ndr, "core_printer_drivers", r->out.core_printer_drivers);
29650                 ndr->depth++;
29651                 ndr->print(ndr, "%s: ARRAY(%d)", "core_printer_drivers", (int)r->in.core_printer_driver_count);
29652                 ndr->depth++;
29653                 for (cntr_core_printer_drivers_1=0;cntr_core_printer_drivers_1<r->in.core_printer_driver_count;cntr_core_printer_drivers_1++) {
29654                         char *idx_1=NULL;
29655                         if (asprintf(&idx_1, "[%d]", cntr_core_printer_drivers_1) != -1) {
29656                                 ndr_print_spoolss_CorePrinterDriver(ndr, "core_printer_drivers", &r->out.core_printer_drivers[cntr_core_printer_drivers_1]);
29657                                 free(idx_1);
29658                         }
29659                 }
29660                 ndr->depth--;
29661                 ndr->depth--;
29662                 ndr_print_WERROR(ndr, "result", r->out.result);
29663                 ndr->depth--;
29664         }
29665         ndr->depth--;
29666 }
29667
29668 static enum ndr_err_code ndr_push_spoolss_67(struct ndr_push *ndr, int flags, const struct spoolss_67 *r)
29669 {
29670         if (flags & NDR_IN) {
29671         }
29672         if (flags & NDR_OUT) {
29673                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29674         }
29675         return NDR_ERR_SUCCESS;
29676 }
29677
29678 static enum ndr_err_code ndr_pull_spoolss_67(struct ndr_pull *ndr, int flags, struct spoolss_67 *r)
29679 {
29680         if (flags & NDR_IN) {
29681         }
29682         if (flags & NDR_OUT) {
29683                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29684         }
29685         return NDR_ERR_SUCCESS;
29686 }
29687
29688 _PUBLIC_ void ndr_print_spoolss_67(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_67 *r)
29689 {
29690         ndr_print_struct(ndr, name, "spoolss_67");
29691         ndr->depth++;
29692         if (flags & NDR_SET_VALUES) {
29693                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29694         }
29695         if (flags & NDR_IN) {
29696                 ndr_print_struct(ndr, "in", "spoolss_67");
29697                 ndr->depth++;
29698                 ndr->depth--;
29699         }
29700         if (flags & NDR_OUT) {
29701                 ndr_print_struct(ndr, "out", "spoolss_67");
29702                 ndr->depth++;
29703                 ndr_print_WERROR(ndr, "result", r->out.result);
29704                 ndr->depth--;
29705         }
29706         ndr->depth--;
29707 }
29708
29709 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriverPackagePath(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
29710 {
29711         if (flags & NDR_IN) {
29712                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29713                 if (r->in.servername) {
29714                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29715                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29716                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29717                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29718                 }
29719                 if (r->in.architecture == NULL) {
29720                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29721                 }
29722                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29723                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29724                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29725                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29726                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.language));
29727                 if (r->in.language) {
29728                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
29729                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29730                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
29731                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.language, ndr_charset_length(r->in.language, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29732                 }
29733                 if (r->in.package_id == NULL) {
29734                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29735                 }
29736                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
29737                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29738                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
29739                 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));
29740                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.driver_package_cab));
29741                 if (r->in.driver_package_cab) {
29742                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29743                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
29744                 }
29745                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29746         }
29747         if (flags & NDR_OUT) {
29748                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.driver_package_cab));
29749                 if (r->out.driver_package_cab) {
29750                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29751                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
29752                 }
29753                 if (r->out.required == NULL) {
29754                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29755                 }
29756                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.required));
29757                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29758         }
29759         return NDR_ERR_SUCCESS;
29760 }
29761
29762 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverPackagePath(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverPackagePath *r)
29763 {
29764         uint32_t _ptr_servername;
29765         uint32_t _ptr_language;
29766         uint32_t _ptr_driver_package_cab;
29767         TALLOC_CTX *_mem_save_servername_0;
29768         TALLOC_CTX *_mem_save_language_0;
29769         TALLOC_CTX *_mem_save_driver_package_cab_0;
29770         TALLOC_CTX *_mem_save_required_0;
29771         if (flags & NDR_IN) {
29772                 ZERO_STRUCT(r->out);
29773
29774                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29775                 if (_ptr_servername) {
29776                         NDR_PULL_ALLOC(ndr, r->in.servername);
29777                 } else {
29778                         r->in.servername = NULL;
29779                 }
29780                 if (r->in.servername) {
29781                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29782                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29783                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29784                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29785                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29786                                 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));
29787                         }
29788                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29789                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29790                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29791                 }
29792                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
29793                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
29794                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
29795                         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));
29796                 }
29797                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
29798                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
29799                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_language));
29800                 if (_ptr_language) {
29801                         NDR_PULL_ALLOC(ndr, r->in.language);
29802                 } else {
29803                         r->in.language = NULL;
29804                 }
29805                 if (r->in.language) {
29806                         _mem_save_language_0 = NDR_PULL_GET_MEM_CTX(ndr);
29807                         NDR_PULL_SET_MEM_CTX(ndr, r->in.language, 0);
29808                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.language));
29809                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.language));
29810                         if (ndr_get_array_length(ndr, &r->in.language) > ndr_get_array_size(ndr, &r->in.language)) {
29811                                 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));
29812                         }
29813                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t)));
29814                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.language, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t), CH_UTF16));
29815                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_language_0, 0);
29816                 }
29817                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.package_id));
29818                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.package_id));
29819                 if (ndr_get_array_length(ndr, &r->in.package_id) > ndr_get_array_size(ndr, &r->in.package_id)) {
29820                         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));
29821                 }
29822                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.package_id), sizeof(uint16_t)));
29823                 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));
29824                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
29825                 if (_ptr_driver_package_cab) {
29826                         NDR_PULL_ALLOC(ndr, r->in.driver_package_cab);
29827                 } else {
29828                         r->in.driver_package_cab = NULL;
29829                 }
29830                 if (r->in.driver_package_cab) {
29831                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
29832                         NDR_PULL_SET_MEM_CTX(ndr, r->in.driver_package_cab, 0);
29833                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver_package_cab));
29834                         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));
29835                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
29836                 }
29837                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.driver_package_cab_size));
29838                 NDR_PULL_ALLOC(ndr, r->out.required);
29839                 ZERO_STRUCTP(r->out.required);
29840                 if (r->in.driver_package_cab) {
29841                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.driver_package_cab, r->in.driver_package_cab_size));
29842                 }
29843         }
29844         if (flags & NDR_OUT) {
29845                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
29846                 if (_ptr_driver_package_cab) {
29847                         NDR_PULL_ALLOC(ndr, r->out.driver_package_cab);
29848                 } else {
29849                         r->out.driver_package_cab = NULL;
29850                 }
29851                 if (r->out.driver_package_cab) {
29852                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
29853                         NDR_PULL_SET_MEM_CTX(ndr, r->out.driver_package_cab, 0);
29854                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.driver_package_cab));
29855                         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));
29856                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
29857                 }
29858                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29859                         NDR_PULL_ALLOC(ndr, r->out.required);
29860                 }
29861                 _mem_save_required_0 = NDR_PULL_GET_MEM_CTX(ndr);
29862                 NDR_PULL_SET_MEM_CTX(ndr, r->out.required, LIBNDR_FLAG_REF_ALLOC);
29863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.required));
29864                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_required_0, LIBNDR_FLAG_REF_ALLOC);
29865                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29866                 if (r->out.driver_package_cab) {
29867                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.driver_package_cab, r->in.driver_package_cab_size));
29868                 }
29869         }
29870         return NDR_ERR_SUCCESS;
29871 }
29872
29873 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverPackagePath(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
29874 {
29875         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverPackagePath");
29876         ndr->depth++;
29877         if (flags & NDR_SET_VALUES) {
29878                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29879         }
29880         if (flags & NDR_IN) {
29881                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverPackagePath");
29882                 ndr->depth++;
29883                 ndr_print_ptr(ndr, "servername", r->in.servername);
29884                 ndr->depth++;
29885                 if (r->in.servername) {
29886                         ndr_print_string(ndr, "servername", r->in.servername);
29887                 }
29888                 ndr->depth--;
29889                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
29890                 ndr->depth++;
29891                 ndr_print_string(ndr, "architecture", r->in.architecture);
29892                 ndr->depth--;
29893                 ndr_print_ptr(ndr, "language", r->in.language);
29894                 ndr->depth++;
29895                 if (r->in.language) {
29896                         ndr_print_string(ndr, "language", r->in.language);
29897                 }
29898                 ndr->depth--;
29899                 ndr_print_ptr(ndr, "package_id", r->in.package_id);
29900                 ndr->depth++;
29901                 ndr_print_string(ndr, "package_id", r->in.package_id);
29902                 ndr->depth--;
29903                 ndr_print_ptr(ndr, "driver_package_cab", r->in.driver_package_cab);
29904                 ndr->depth++;
29905                 if (r->in.driver_package_cab) {
29906                         ndr_print_string(ndr, "driver_package_cab", r->in.driver_package_cab);
29907                 }
29908                 ndr->depth--;
29909                 ndr_print_uint32(ndr, "driver_package_cab_size", r->in.driver_package_cab_size);
29910                 ndr->depth--;
29911         }
29912         if (flags & NDR_OUT) {
29913                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverPackagePath");
29914                 ndr->depth++;
29915                 ndr_print_ptr(ndr, "driver_package_cab", r->out.driver_package_cab);
29916                 ndr->depth++;
29917                 if (r->out.driver_package_cab) {
29918                         ndr_print_string(ndr, "driver_package_cab", r->out.driver_package_cab);
29919                 }
29920                 ndr->depth--;
29921                 ndr_print_ptr(ndr, "required", r->out.required);
29922                 ndr->depth++;
29923                 ndr_print_uint32(ndr, "required", *r->out.required);
29924                 ndr->depth--;
29925                 ndr_print_WERROR(ndr, "result", r->out.result);
29926                 ndr->depth--;
29927         }
29928         ndr->depth--;
29929 }
29930
29931 static enum ndr_err_code ndr_push_spoolss_69(struct ndr_push *ndr, int flags, const struct spoolss_69 *r)
29932 {
29933         if (flags & NDR_IN) {
29934         }
29935         if (flags & NDR_OUT) {
29936                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29937         }
29938         return NDR_ERR_SUCCESS;
29939 }
29940
29941 static enum ndr_err_code ndr_pull_spoolss_69(struct ndr_pull *ndr, int flags, struct spoolss_69 *r)
29942 {
29943         if (flags & NDR_IN) {
29944         }
29945         if (flags & NDR_OUT) {
29946                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29947         }
29948         return NDR_ERR_SUCCESS;
29949 }
29950
29951 _PUBLIC_ void ndr_print_spoolss_69(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_69 *r)
29952 {
29953         ndr_print_struct(ndr, name, "spoolss_69");
29954         ndr->depth++;
29955         if (flags & NDR_SET_VALUES) {
29956                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29957         }
29958         if (flags & NDR_IN) {
29959                 ndr_print_struct(ndr, "in", "spoolss_69");
29960                 ndr->depth++;
29961                 ndr->depth--;
29962         }
29963         if (flags & NDR_OUT) {
29964                 ndr_print_struct(ndr, "out", "spoolss_69");
29965                 ndr->depth++;
29966                 ndr_print_WERROR(ndr, "result", r->out.result);
29967                 ndr->depth--;
29968         }
29969         ndr->depth--;
29970 }
29971
29972 static enum ndr_err_code ndr_push_spoolss_6a(struct ndr_push *ndr, int flags, const struct spoolss_6a *r)
29973 {
29974         if (flags & NDR_IN) {
29975         }
29976         if (flags & NDR_OUT) {
29977                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29978         }
29979         return NDR_ERR_SUCCESS;
29980 }
29981
29982 static enum ndr_err_code ndr_pull_spoolss_6a(struct ndr_pull *ndr, int flags, struct spoolss_6a *r)
29983 {
29984         if (flags & NDR_IN) {
29985         }
29986         if (flags & NDR_OUT) {
29987                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29988         }
29989         return NDR_ERR_SUCCESS;
29990 }
29991
29992 _PUBLIC_ void ndr_print_spoolss_6a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6a *r)
29993 {
29994         ndr_print_struct(ndr, name, "spoolss_6a");
29995         ndr->depth++;
29996         if (flags & NDR_SET_VALUES) {
29997                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29998         }
29999         if (flags & NDR_IN) {
30000                 ndr_print_struct(ndr, "in", "spoolss_6a");
30001                 ndr->depth++;
30002                 ndr->depth--;
30003         }
30004         if (flags & NDR_OUT) {
30005                 ndr_print_struct(ndr, "out", "spoolss_6a");
30006                 ndr->depth++;
30007                 ndr_print_WERROR(ndr, "result", r->out.result);
30008                 ndr->depth--;
30009         }
30010         ndr->depth--;
30011 }
30012
30013 static enum ndr_err_code ndr_push_spoolss_6b(struct ndr_push *ndr, int flags, const struct spoolss_6b *r)
30014 {
30015         if (flags & NDR_IN) {
30016         }
30017         if (flags & NDR_OUT) {
30018                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30019         }
30020         return NDR_ERR_SUCCESS;
30021 }
30022
30023 static enum ndr_err_code ndr_pull_spoolss_6b(struct ndr_pull *ndr, int flags, struct spoolss_6b *r)
30024 {
30025         if (flags & NDR_IN) {
30026         }
30027         if (flags & NDR_OUT) {
30028                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30029         }
30030         return NDR_ERR_SUCCESS;
30031 }
30032
30033 _PUBLIC_ void ndr_print_spoolss_6b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6b *r)
30034 {
30035         ndr_print_struct(ndr, name, "spoolss_6b");
30036         ndr->depth++;
30037         if (flags & NDR_SET_VALUES) {
30038                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30039         }
30040         if (flags & NDR_IN) {
30041                 ndr_print_struct(ndr, "in", "spoolss_6b");
30042                 ndr->depth++;
30043                 ndr->depth--;
30044         }
30045         if (flags & NDR_OUT) {
30046                 ndr_print_struct(ndr, "out", "spoolss_6b");
30047                 ndr->depth++;
30048                 ndr_print_WERROR(ndr, "result", r->out.result);
30049                 ndr->depth--;
30050         }
30051         ndr->depth--;
30052 }
30053
30054 static enum ndr_err_code ndr_push_spoolss_6c(struct ndr_push *ndr, int flags, const struct spoolss_6c *r)
30055 {
30056         if (flags & NDR_IN) {
30057         }
30058         if (flags & NDR_OUT) {
30059                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30060         }
30061         return NDR_ERR_SUCCESS;
30062 }
30063
30064 static enum ndr_err_code ndr_pull_spoolss_6c(struct ndr_pull *ndr, int flags, struct spoolss_6c *r)
30065 {
30066         if (flags & NDR_IN) {
30067         }
30068         if (flags & NDR_OUT) {
30069                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30070         }
30071         return NDR_ERR_SUCCESS;
30072 }
30073
30074 _PUBLIC_ void ndr_print_spoolss_6c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6c *r)
30075 {
30076         ndr_print_struct(ndr, name, "spoolss_6c");
30077         ndr->depth++;
30078         if (flags & NDR_SET_VALUES) {
30079                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30080         }
30081         if (flags & NDR_IN) {
30082                 ndr_print_struct(ndr, "in", "spoolss_6c");
30083                 ndr->depth++;
30084                 ndr->depth--;
30085         }
30086         if (flags & NDR_OUT) {
30087                 ndr_print_struct(ndr, "out", "spoolss_6c");
30088                 ndr->depth++;
30089                 ndr_print_WERROR(ndr, "result", r->out.result);
30090                 ndr->depth--;
30091         }
30092         ndr->depth--;
30093 }
30094
30095 static enum ndr_err_code ndr_push_spoolss_6d(struct ndr_push *ndr, int flags, const struct spoolss_6d *r)
30096 {
30097         if (flags & NDR_IN) {
30098         }
30099         if (flags & NDR_OUT) {
30100                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30101         }
30102         return NDR_ERR_SUCCESS;
30103 }
30104
30105 static enum ndr_err_code ndr_pull_spoolss_6d(struct ndr_pull *ndr, int flags, struct spoolss_6d *r)
30106 {
30107         if (flags & NDR_IN) {
30108         }
30109         if (flags & NDR_OUT) {
30110                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30111         }
30112         return NDR_ERR_SUCCESS;
30113 }
30114
30115 _PUBLIC_ void ndr_print_spoolss_6d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6d *r)
30116 {
30117         ndr_print_struct(ndr, name, "spoolss_6d");
30118         ndr->depth++;
30119         if (flags & NDR_SET_VALUES) {
30120                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30121         }
30122         if (flags & NDR_IN) {
30123                 ndr_print_struct(ndr, "in", "spoolss_6d");
30124                 ndr->depth++;
30125                 ndr->depth--;
30126         }
30127         if (flags & NDR_OUT) {
30128                 ndr_print_struct(ndr, "out", "spoolss_6d");
30129                 ndr->depth++;
30130                 ndr_print_WERROR(ndr, "result", r->out.result);
30131                 ndr->depth--;
30132         }
30133         ndr->depth--;
30134 }
30135
30136 static const struct ndr_interface_call spoolss_calls[] = {
30137         {
30138                 "spoolss_EnumPrinters",
30139                 sizeof(struct spoolss_EnumPrinters),
30140                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
30141                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
30142                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
30143                 false,
30144         },
30145         {
30146                 "spoolss_OpenPrinter",
30147                 sizeof(struct spoolss_OpenPrinter),
30148                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
30149                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
30150                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
30151                 false,
30152         },
30153         {
30154                 "spoolss_SetJob",
30155                 sizeof(struct spoolss_SetJob),
30156                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
30157                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
30158                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
30159                 false,
30160         },
30161         {
30162                 "spoolss_GetJob",
30163                 sizeof(struct spoolss_GetJob),
30164                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
30165                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
30166                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
30167                 false,
30168         },
30169         {
30170                 "spoolss_EnumJobs",
30171                 sizeof(struct spoolss_EnumJobs),
30172                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
30173                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
30174                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
30175                 false,
30176         },
30177         {
30178                 "spoolss_AddPrinter",
30179                 sizeof(struct spoolss_AddPrinter),
30180                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
30181                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
30182                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
30183                 false,
30184         },
30185         {
30186                 "spoolss_DeletePrinter",
30187                 sizeof(struct spoolss_DeletePrinter),
30188                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
30189                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
30190                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
30191                 false,
30192         },
30193         {
30194                 "spoolss_SetPrinter",
30195                 sizeof(struct spoolss_SetPrinter),
30196                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
30197                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
30198                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
30199                 false,
30200         },
30201         {
30202                 "spoolss_GetPrinter",
30203                 sizeof(struct spoolss_GetPrinter),
30204                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
30205                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
30206                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
30207                 false,
30208         },
30209         {
30210                 "spoolss_AddPrinterDriver",
30211                 sizeof(struct spoolss_AddPrinterDriver),
30212                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
30213                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
30214                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
30215                 false,
30216         },
30217         {
30218                 "spoolss_EnumPrinterDrivers",
30219                 sizeof(struct spoolss_EnumPrinterDrivers),
30220                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
30221                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
30222                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
30223                 false,
30224         },
30225         {
30226                 "spoolss_GetPrinterDriver",
30227                 sizeof(struct spoolss_GetPrinterDriver),
30228                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
30229                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
30230                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
30231                 false,
30232         },
30233         {
30234                 "spoolss_GetPrinterDriverDirectory",
30235                 sizeof(struct spoolss_GetPrinterDriverDirectory),
30236                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
30237                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
30238                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
30239                 false,
30240         },
30241         {
30242                 "spoolss_DeletePrinterDriver",
30243                 sizeof(struct spoolss_DeletePrinterDriver),
30244                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
30245                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
30246                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
30247                 false,
30248         },
30249         {
30250                 "spoolss_AddPrintProcessor",
30251                 sizeof(struct spoolss_AddPrintProcessor),
30252                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
30253                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
30254                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
30255                 false,
30256         },
30257         {
30258                 "spoolss_EnumPrintProcessors",
30259                 sizeof(struct spoolss_EnumPrintProcessors),
30260                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
30261                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
30262                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
30263                 false,
30264         },
30265         {
30266                 "spoolss_GetPrintProcessorDirectory",
30267                 sizeof(struct spoolss_GetPrintProcessorDirectory),
30268                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
30269                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
30270                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
30271                 false,
30272         },
30273         {
30274                 "spoolss_StartDocPrinter",
30275                 sizeof(struct spoolss_StartDocPrinter),
30276                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
30277                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
30278                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
30279                 false,
30280         },
30281         {
30282                 "spoolss_StartPagePrinter",
30283                 sizeof(struct spoolss_StartPagePrinter),
30284                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
30285                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
30286                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
30287                 false,
30288         },
30289         {
30290                 "spoolss_WritePrinter",
30291                 sizeof(struct spoolss_WritePrinter),
30292                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
30293                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
30294                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
30295                 false,
30296         },
30297         {
30298                 "spoolss_EndPagePrinter",
30299                 sizeof(struct spoolss_EndPagePrinter),
30300                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
30301                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
30302                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
30303                 false,
30304         },
30305         {
30306                 "spoolss_AbortPrinter",
30307                 sizeof(struct spoolss_AbortPrinter),
30308                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
30309                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
30310                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
30311                 false,
30312         },
30313         {
30314                 "spoolss_ReadPrinter",
30315                 sizeof(struct spoolss_ReadPrinter),
30316                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
30317                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
30318                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
30319                 false,
30320         },
30321         {
30322                 "spoolss_EndDocPrinter",
30323                 sizeof(struct spoolss_EndDocPrinter),
30324                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
30325                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
30326                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
30327                 false,
30328         },
30329         {
30330                 "spoolss_AddJob",
30331                 sizeof(struct spoolss_AddJob),
30332                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
30333                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
30334                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
30335                 false,
30336         },
30337         {
30338                 "spoolss_ScheduleJob",
30339                 sizeof(struct spoolss_ScheduleJob),
30340                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
30341                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
30342                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
30343                 false,
30344         },
30345         {
30346                 "spoolss_GetPrinterData",
30347                 sizeof(struct spoolss_GetPrinterData),
30348                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
30349                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
30350                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
30351                 false,
30352         },
30353         {
30354                 "spoolss_SetPrinterData",
30355                 sizeof(struct spoolss_SetPrinterData),
30356                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
30357                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
30358                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
30359                 false,
30360         },
30361         {
30362                 "spoolss_WaitForPrinterChange",
30363                 sizeof(struct spoolss_WaitForPrinterChange),
30364                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
30365                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
30366                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
30367                 false,
30368         },
30369         {
30370                 "spoolss_ClosePrinter",
30371                 sizeof(struct spoolss_ClosePrinter),
30372                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
30373                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
30374                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
30375                 false,
30376         },
30377         {
30378                 "spoolss_AddForm",
30379                 sizeof(struct spoolss_AddForm),
30380                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
30381                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
30382                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
30383                 false,
30384         },
30385         {
30386                 "spoolss_DeleteForm",
30387                 sizeof(struct spoolss_DeleteForm),
30388                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
30389                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
30390                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
30391                 false,
30392         },
30393         {
30394                 "spoolss_GetForm",
30395                 sizeof(struct spoolss_GetForm),
30396                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
30397                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
30398                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
30399                 false,
30400         },
30401         {
30402                 "spoolss_SetForm",
30403                 sizeof(struct spoolss_SetForm),
30404                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
30405                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
30406                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
30407                 false,
30408         },
30409         {
30410                 "spoolss_EnumForms",
30411                 sizeof(struct spoolss_EnumForms),
30412                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
30413                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
30414                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
30415                 false,
30416         },
30417         {
30418                 "spoolss_EnumPorts",
30419                 sizeof(struct spoolss_EnumPorts),
30420                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
30421                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
30422                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
30423                 false,
30424         },
30425         {
30426                 "spoolss_EnumMonitors",
30427                 sizeof(struct spoolss_EnumMonitors),
30428                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
30429                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
30430                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
30431                 false,
30432         },
30433         {
30434                 "spoolss_AddPort",
30435                 sizeof(struct spoolss_AddPort),
30436                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
30437                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
30438                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
30439                 false,
30440         },
30441         {
30442                 "spoolss_ConfigurePort",
30443                 sizeof(struct spoolss_ConfigurePort),
30444                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
30445                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
30446                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
30447                 false,
30448         },
30449         {
30450                 "spoolss_DeletePort",
30451                 sizeof(struct spoolss_DeletePort),
30452                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
30453                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
30454                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
30455                 false,
30456         },
30457         {
30458                 "spoolss_CreatePrinterIC",
30459                 sizeof(struct spoolss_CreatePrinterIC),
30460                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
30461                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
30462                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
30463                 false,
30464         },
30465         {
30466                 "spoolss_PlayGDIScriptOnPrinterIC",
30467                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
30468                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
30469                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
30470                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
30471                 false,
30472         },
30473         {
30474                 "spoolss_DeletePrinterIC",
30475                 sizeof(struct spoolss_DeletePrinterIC),
30476                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
30477                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
30478                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
30479                 false,
30480         },
30481         {
30482                 "spoolss_AddPrinterConnection",
30483                 sizeof(struct spoolss_AddPrinterConnection),
30484                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
30485                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
30486                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
30487                 false,
30488         },
30489         {
30490                 "spoolss_DeletePrinterConnection",
30491                 sizeof(struct spoolss_DeletePrinterConnection),
30492                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
30493                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
30494                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
30495                 false,
30496         },
30497         {
30498                 "spoolss_PrinterMessageBox",
30499                 sizeof(struct spoolss_PrinterMessageBox),
30500                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
30501                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
30502                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
30503                 false,
30504         },
30505         {
30506                 "spoolss_AddMonitor",
30507                 sizeof(struct spoolss_AddMonitor),
30508                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
30509                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
30510                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
30511                 false,
30512         },
30513         {
30514                 "spoolss_DeleteMonitor",
30515                 sizeof(struct spoolss_DeleteMonitor),
30516                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
30517                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
30518                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
30519                 false,
30520         },
30521         {
30522                 "spoolss_DeletePrintProcessor",
30523                 sizeof(struct spoolss_DeletePrintProcessor),
30524                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
30525                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
30526                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
30527                 false,
30528         },
30529         {
30530                 "spoolss_AddPrintProvidor",
30531                 sizeof(struct spoolss_AddPrintProvidor),
30532                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
30533                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
30534                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
30535                 false,
30536         },
30537         {
30538                 "spoolss_DeletePrintProvidor",
30539                 sizeof(struct spoolss_DeletePrintProvidor),
30540                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
30541                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
30542                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
30543                 false,
30544         },
30545         {
30546                 "spoolss_EnumPrintProcDataTypes",
30547                 sizeof(struct spoolss_EnumPrintProcDataTypes),
30548                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
30549                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
30550                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
30551                 false,
30552         },
30553         {
30554                 "spoolss_ResetPrinter",
30555                 sizeof(struct spoolss_ResetPrinter),
30556                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
30557                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
30558                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
30559                 false,
30560         },
30561         {
30562                 "spoolss_GetPrinterDriver2",
30563                 sizeof(struct spoolss_GetPrinterDriver2),
30564                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
30565                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
30566                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
30567                 false,
30568         },
30569         {
30570                 "spoolss_FindFirstPrinterChangeNotification",
30571                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
30572                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
30573                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
30574                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
30575                 false,
30576         },
30577         {
30578                 "spoolss_FindNextPrinterChangeNotification",
30579                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
30580                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
30581                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
30582                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
30583                 false,
30584         },
30585         {
30586                 "spoolss_FindClosePrinterNotify",
30587                 sizeof(struct spoolss_FindClosePrinterNotify),
30588                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
30589                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
30590                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
30591                 false,
30592         },
30593         {
30594                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
30595                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
30596                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30597                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30598                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30599                 false,
30600         },
30601         {
30602                 "spoolss_ReplyOpenPrinter",
30603                 sizeof(struct spoolss_ReplyOpenPrinter),
30604                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
30605                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
30606                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
30607                 false,
30608         },
30609         {
30610                 "spoolss_RouterReplyPrinter",
30611                 sizeof(struct spoolss_RouterReplyPrinter),
30612                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
30613                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
30614                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
30615                 false,
30616         },
30617         {
30618                 "spoolss_ReplyClosePrinter",
30619                 sizeof(struct spoolss_ReplyClosePrinter),
30620                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
30621                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
30622                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
30623                 false,
30624         },
30625         {
30626                 "spoolss_AddPortEx",
30627                 sizeof(struct spoolss_AddPortEx),
30628                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
30629                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
30630                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
30631                 false,
30632         },
30633         {
30634                 "spoolss_RouterFindFirstPrinterChangeNotification",
30635                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
30636                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
30637                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
30638                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
30639                 false,
30640         },
30641         {
30642                 "spoolss_SpoolerInit",
30643                 sizeof(struct spoolss_SpoolerInit),
30644                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
30645                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
30646                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
30647                 false,
30648         },
30649         {
30650                 "spoolss_ResetPrinterEx",
30651                 sizeof(struct spoolss_ResetPrinterEx),
30652                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
30653                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
30654                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
30655                 false,
30656         },
30657         {
30658                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
30659                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
30660                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30661                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30662                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30663                 false,
30664         },
30665         {
30666                 "spoolss_RouterReplyPrinterEx",
30667                 sizeof(struct spoolss_RouterReplyPrinterEx),
30668                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
30669                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
30670                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
30671                 false,
30672         },
30673         {
30674                 "spoolss_RouterRefreshPrinterChangeNotify",
30675                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
30676                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
30677                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
30678                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
30679                 false,
30680         },
30681         {
30682                 "spoolss_44",
30683                 sizeof(struct spoolss_44),
30684                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
30685                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
30686                 (ndr_print_function_t) ndr_print_spoolss_44,
30687                 false,
30688         },
30689         {
30690                 "spoolss_OpenPrinterEx",
30691                 sizeof(struct spoolss_OpenPrinterEx),
30692                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
30693                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
30694                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
30695                 false,
30696         },
30697         {
30698                 "spoolss_AddPrinterEx",
30699                 sizeof(struct spoolss_AddPrinterEx),
30700                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
30701                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
30702                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
30703                 false,
30704         },
30705         {
30706                 "spoolss_47",
30707                 sizeof(struct spoolss_47),
30708                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
30709                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
30710                 (ndr_print_function_t) ndr_print_spoolss_47,
30711                 false,
30712         },
30713         {
30714                 "spoolss_EnumPrinterData",
30715                 sizeof(struct spoolss_EnumPrinterData),
30716                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
30717                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
30718                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
30719                 false,
30720         },
30721         {
30722                 "spoolss_DeletePrinterData",
30723                 sizeof(struct spoolss_DeletePrinterData),
30724                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
30725                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
30726                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
30727                 false,
30728         },
30729         {
30730                 "spoolss_4a",
30731                 sizeof(struct spoolss_4a),
30732                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
30733                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
30734                 (ndr_print_function_t) ndr_print_spoolss_4a,
30735                 false,
30736         },
30737         {
30738                 "spoolss_4b",
30739                 sizeof(struct spoolss_4b),
30740                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
30741                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
30742                 (ndr_print_function_t) ndr_print_spoolss_4b,
30743                 false,
30744         },
30745         {
30746                 "spoolss_4c",
30747                 sizeof(struct spoolss_4c),
30748                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
30749                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
30750                 (ndr_print_function_t) ndr_print_spoolss_4c,
30751                 false,
30752         },
30753         {
30754                 "spoolss_SetPrinterDataEx",
30755                 sizeof(struct spoolss_SetPrinterDataEx),
30756                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
30757                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
30758                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
30759                 false,
30760         },
30761         {
30762                 "spoolss_GetPrinterDataEx",
30763                 sizeof(struct spoolss_GetPrinterDataEx),
30764                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
30765                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
30766                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
30767                 false,
30768         },
30769         {
30770                 "spoolss_EnumPrinterDataEx",
30771                 sizeof(struct spoolss_EnumPrinterDataEx),
30772                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
30773                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
30774                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
30775                 false,
30776         },
30777         {
30778                 "spoolss_EnumPrinterKey",
30779                 sizeof(struct spoolss_EnumPrinterKey),
30780                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
30781                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
30782                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
30783                 false,
30784         },
30785         {
30786                 "spoolss_DeletePrinterDataEx",
30787                 sizeof(struct spoolss_DeletePrinterDataEx),
30788                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
30789                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
30790                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
30791                 false,
30792         },
30793         {
30794                 "spoolss_DeletePrinterKey",
30795                 sizeof(struct spoolss_DeletePrinterKey),
30796                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
30797                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
30798                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
30799                 false,
30800         },
30801         {
30802                 "spoolss_53",
30803                 sizeof(struct spoolss_53),
30804                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
30805                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
30806                 (ndr_print_function_t) ndr_print_spoolss_53,
30807                 false,
30808         },
30809         {
30810                 "spoolss_DeletePrinterDriverEx",
30811                 sizeof(struct spoolss_DeletePrinterDriverEx),
30812                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
30813                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
30814                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
30815                 false,
30816         },
30817         {
30818                 "spoolss_55",
30819                 sizeof(struct spoolss_55),
30820                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
30821                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
30822                 (ndr_print_function_t) ndr_print_spoolss_55,
30823                 false,
30824         },
30825         {
30826                 "spoolss_56",
30827                 sizeof(struct spoolss_56),
30828                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
30829                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
30830                 (ndr_print_function_t) ndr_print_spoolss_56,
30831                 false,
30832         },
30833         {
30834                 "spoolss_57",
30835                 sizeof(struct spoolss_57),
30836                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
30837                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
30838                 (ndr_print_function_t) ndr_print_spoolss_57,
30839                 false,
30840         },
30841         {
30842                 "spoolss_XcvData",
30843                 sizeof(struct spoolss_XcvData),
30844                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
30845                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
30846                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
30847                 false,
30848         },
30849         {
30850                 "spoolss_AddPrinterDriverEx",
30851                 sizeof(struct spoolss_AddPrinterDriverEx),
30852                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
30853                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
30854                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
30855                 false,
30856         },
30857         {
30858                 "spoolss_5a",
30859                 sizeof(struct spoolss_5a),
30860                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
30861                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
30862                 (ndr_print_function_t) ndr_print_spoolss_5a,
30863                 false,
30864         },
30865         {
30866                 "spoolss_5b",
30867                 sizeof(struct spoolss_5b),
30868                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
30869                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
30870                 (ndr_print_function_t) ndr_print_spoolss_5b,
30871                 false,
30872         },
30873         {
30874                 "spoolss_5c",
30875                 sizeof(struct spoolss_5c),
30876                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
30877                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
30878                 (ndr_print_function_t) ndr_print_spoolss_5c,
30879                 false,
30880         },
30881         {
30882                 "spoolss_5d",
30883                 sizeof(struct spoolss_5d),
30884                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
30885                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
30886                 (ndr_print_function_t) ndr_print_spoolss_5d,
30887                 false,
30888         },
30889         {
30890                 "spoolss_5e",
30891                 sizeof(struct spoolss_5e),
30892                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
30893                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
30894                 (ndr_print_function_t) ndr_print_spoolss_5e,
30895                 false,
30896         },
30897         {
30898                 "spoolss_5f",
30899                 sizeof(struct spoolss_5f),
30900                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
30901                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
30902                 (ndr_print_function_t) ndr_print_spoolss_5f,
30903                 false,
30904         },
30905         {
30906                 "spoolss_60",
30907                 sizeof(struct spoolss_60),
30908                 (ndr_push_flags_fn_t) ndr_push_spoolss_60,
30909                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_60,
30910                 (ndr_print_function_t) ndr_print_spoolss_60,
30911                 false,
30912         },
30913         {
30914                 "spoolss_61",
30915                 sizeof(struct spoolss_61),
30916                 (ndr_push_flags_fn_t) ndr_push_spoolss_61,
30917                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_61,
30918                 (ndr_print_function_t) ndr_print_spoolss_61,
30919                 false,
30920         },
30921         {
30922                 "spoolss_62",
30923                 sizeof(struct spoolss_62),
30924                 (ndr_push_flags_fn_t) ndr_push_spoolss_62,
30925                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_62,
30926                 (ndr_print_function_t) ndr_print_spoolss_62,
30927                 false,
30928         },
30929         {
30930                 "spoolss_63",
30931                 sizeof(struct spoolss_63),
30932                 (ndr_push_flags_fn_t) ndr_push_spoolss_63,
30933                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_63,
30934                 (ndr_print_function_t) ndr_print_spoolss_63,
30935                 false,
30936         },
30937         {
30938                 "spoolss_64",
30939                 sizeof(struct spoolss_64),
30940                 (ndr_push_flags_fn_t) ndr_push_spoolss_64,
30941                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_64,
30942                 (ndr_print_function_t) ndr_print_spoolss_64,
30943                 false,
30944         },
30945         {
30946                 "spoolss_65",
30947                 sizeof(struct spoolss_65),
30948                 (ndr_push_flags_fn_t) ndr_push_spoolss_65,
30949                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_65,
30950                 (ndr_print_function_t) ndr_print_spoolss_65,
30951                 false,
30952         },
30953         {
30954                 "spoolss_GetCorePrinterDrivers",
30955                 sizeof(struct spoolss_GetCorePrinterDrivers),
30956                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetCorePrinterDrivers,
30957                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetCorePrinterDrivers,
30958                 (ndr_print_function_t) ndr_print_spoolss_GetCorePrinterDrivers,
30959                 false,
30960         },
30961         {
30962                 "spoolss_67",
30963                 sizeof(struct spoolss_67),
30964                 (ndr_push_flags_fn_t) ndr_push_spoolss_67,
30965                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_67,
30966                 (ndr_print_function_t) ndr_print_spoolss_67,
30967                 false,
30968         },
30969         {
30970                 "spoolss_GetPrinterDriverPackagePath",
30971                 sizeof(struct spoolss_GetPrinterDriverPackagePath),
30972                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverPackagePath,
30973                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverPackagePath,
30974                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverPackagePath,
30975                 false,
30976         },
30977         {
30978                 "spoolss_69",
30979                 sizeof(struct spoolss_69),
30980                 (ndr_push_flags_fn_t) ndr_push_spoolss_69,
30981                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_69,
30982                 (ndr_print_function_t) ndr_print_spoolss_69,
30983                 false,
30984         },
30985         {
30986                 "spoolss_6a",
30987                 sizeof(struct spoolss_6a),
30988                 (ndr_push_flags_fn_t) ndr_push_spoolss_6a,
30989                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6a,
30990                 (ndr_print_function_t) ndr_print_spoolss_6a,
30991                 false,
30992         },
30993         {
30994                 "spoolss_6b",
30995                 sizeof(struct spoolss_6b),
30996                 (ndr_push_flags_fn_t) ndr_push_spoolss_6b,
30997                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6b,
30998                 (ndr_print_function_t) ndr_print_spoolss_6b,
30999                 false,
31000         },
31001         {
31002                 "spoolss_6c",
31003                 sizeof(struct spoolss_6c),
31004                 (ndr_push_flags_fn_t) ndr_push_spoolss_6c,
31005                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6c,
31006                 (ndr_print_function_t) ndr_print_spoolss_6c,
31007                 false,
31008         },
31009         {
31010                 "spoolss_6d",
31011                 sizeof(struct spoolss_6d),
31012                 (ndr_push_flags_fn_t) ndr_push_spoolss_6d,
31013                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6d,
31014                 (ndr_print_function_t) ndr_print_spoolss_6d,
31015                 false,
31016         },
31017         { NULL, 0, NULL, NULL, NULL, false }
31018 };
31019
31020 static const char * const spoolss_endpoint_strings[] = {
31021         "ncacn_np:[\\pipe\\spoolss]",
31022 };
31023
31024 static const struct ndr_interface_string_array spoolss_endpoints = {
31025         .count  = 1,
31026         .names  = spoolss_endpoint_strings
31027 };
31028
31029 static const char * const spoolss_authservice_strings[] = {
31030         "host",
31031 };
31032
31033 static const struct ndr_interface_string_array spoolss_authservices = {
31034         .count  = 1,
31035         .names  = spoolss_authservice_strings
31036 };
31037
31038
31039 const struct ndr_interface_table ndr_table_spoolss = {
31040         .name           = "spoolss",
31041         .syntax_id      = {
31042                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
31043                 NDR_SPOOLSS_VERSION
31044         },
31045         .helpstring     = NDR_SPOOLSS_HELPSTRING,
31046         .num_calls      = 110,
31047         .calls          = spoolss_calls,
31048         .endpoints      = &spoolss_endpoints,
31049         .authservices   = &spoolss_authservices
31050 };
31051